1
// GENERATED BY ISLE. DO NOT EDIT!
2
//
3
// Generated automatically from the instruction-selection DSL code in:
4
// - src/prelude.isle
5
// - src/prelude_opt.isle
6
// - src/opts/algebraic.isle
7
// - src/opts/icmp.isle
8
// - src/opts/cprop.isle
9
// - /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle
10

            
11
use super::*; // Pulls in all external types.
12
use std::marker::PhantomData;
13

            
14
/// Context during lowering: an implementation of this trait
15
/// must be provided with all external constructors and extractors.
16
/// A mutable borrow is passed along through all lowering logic.
17
pub trait Context {
18
    fn unit(&mut self) -> Unit;
19
    fn value_type(&mut self, arg0: Value) -> Type;
20
    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;
21
    fn offset32(&mut self, arg0: Offset32) -> u32;
22
    fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option<Unit>;
23
    fn u8_lteq(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;
24
    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;
25
    fn simm32(&mut self, arg0: Imm64) -> Option<u32>;
26
    fn uimm8(&mut self, arg0: Imm64) -> Option<u8>;
27
    fn u8_as_u32(&mut self, arg0: u8) -> u32;
28
    fn u8_as_u64(&mut self, arg0: u8) -> u64;
29
    fn u16_as_u64(&mut self, arg0: u16) -> u64;
30
    fn u32_as_u64(&mut self, arg0: u32) -> u64;
31
    fn i64_as_u64(&mut self, arg0: i64) -> u64;
32
    fn i64_neg(&mut self, arg0: i64) -> i64;
33
    fn u128_as_u64(&mut self, arg0: u128) -> Option<u64>;
34
    fn u64_as_u32(&mut self, arg0: u64) -> Option<u32>;
35
    fn u64_as_i32(&mut self, arg0: u64) -> i32;
36
    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
37
    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;
38
    fn s32_add_fallible(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
39
    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;
40
    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;
41
    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;
42
    fn u64_sdiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
43
    fn u64_udiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
44
    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;
45
    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;
46
    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;
47
    fn u64_shl(&mut self, arg0: u64, arg1: u64) -> u64;
48
    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
49
    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
50
    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
51
    fn u64_not(&mut self, arg0: u64) -> u64;
52
    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;
53
    fn u64_le(&mut self, arg0: u64, arg1: u64) -> bool;
54
    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;
55
    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;
56
    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;
57
    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;
58
    fn u64_is_zero(&mut self, arg0: u64) -> bool;
59
    fn u64_is_odd(&mut self, arg0: u64) -> bool;
60
    fn ty_umin(&mut self, arg0: Type) -> u64;
61
    fn ty_umax(&mut self, arg0: Type) -> u64;
62
    fn ty_smin(&mut self, arg0: Type) -> u64;
63
    fn ty_smax(&mut self, arg0: Type) -> u64;
64
    fn ty_bits(&mut self, arg0: Type) -> u8;
65
    fn ty_bits_u16(&mut self, arg0: Type) -> u16;
66
    fn ty_bits_u64(&mut self, arg0: Type) -> u64;
67
    fn ty_mask(&mut self, arg0: Type) -> u64;
68
    fn ty_bytes(&mut self, arg0: Type) -> u16;
69
    fn lane_type(&mut self, arg0: Type) -> Type;
70
    fn mem_flags_trusted(&mut self) -> MemFlags;
71
    fn intcc_reverse(&mut self, arg0: &IntCC) -> IntCC;
72
    fn intcc_inverse(&mut self, arg0: &IntCC) -> IntCC;
73
    fn floatcc_reverse(&mut self, arg0: &FloatCC) -> FloatCC;
74
    fn floatcc_inverse(&mut self, arg0: &FloatCC) -> FloatCC;
75
    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;
76
    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
77
    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
78
    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
79
    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
80
    fn ty_32(&mut self, arg0: Type) -> Option<Type>;
81
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;
82
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;
83
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
84
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
85
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
86
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;
87
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;
88
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
89
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;
90
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;
91
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;
92
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;
93
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;
94
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
95
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;
96
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;
97
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;
98
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
99
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;
100
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;
101
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
102
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
103
    fn u64_from_bool(&mut self, arg0: bool) -> u64;
104
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
105
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
106
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;
107
    fn imm64(&mut self, arg0: u64) -> Imm64;
108
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;
109
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;
110
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
111
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
112
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
113
    fn dynamic_int_lane(&mut self, arg0: Type) -> Option<u32>;
114
    fn dynamic_fp_lane(&mut self, arg0: Type) -> Option<u32>;
115
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;
116
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;
117
    fn offset32_to_u32(&mut self, arg0: Offset32) -> u32;
118
    fn u32_to_offset32(&mut self, arg0: u32) -> Offset32;
119
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;
120
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
121
    fn trap_code_division_by_zero(&mut self) -> TrapCode;
122
    fn trap_code_integer_overflow(&mut self) -> TrapCode;
123
    fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;
124
    fn range(&mut self, arg0: usize, arg1: usize) -> Range;
125
    fn range_view(&mut self, arg0: Range) -> RangeView;
126
    type inst_data_etor_iter: ContextIter<Context = Self, Output = (Type, InstructionData)>;
127
    fn inst_data_etor(&mut self, arg0: Value) -> Self::inst_data_etor_iter;
128
    fn make_inst_ctor(&mut self, arg0: Type, arg1: &InstructionData) -> Value;
129
    fn value_array_2_ctor(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
130
    fn value_array_3_ctor(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
131
    fn remat(&mut self, arg0: Value) -> Value;
132
    fn subsume(&mut self, arg0: Value) -> Value;
133
    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);
134
    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
135
    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);
136
    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
137
    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);
138
    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;
139
}
140

            
141
pub trait ContextIter {
142
    type Context;
143
    type Output;
144
    fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;
145
}
146

            
147
pub struct ContextIterWrapper<Item, I: Iterator<Item = Item>, C: Context> {
148
    iter: I,
149
    _ctx: PhantomData<C>,
150
}
151
impl<Item, I: Iterator<Item = Item>, C: Context> From<I> for ContextIterWrapper<Item, I, C> {
152
    fn from(iter: I) -> Self {
153
        Self {
154
            iter,
155
            _ctx: PhantomData,
156
        }
157
    }
158
}
159
impl<Item, I: Iterator<Item = Item>, C: Context> ContextIter for ContextIterWrapper<Item, I, C> {
160
    type Context = C;
161
    type Output = Item;
162
    fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {
163
        self.iter.next()
164
    }
165
}
166

            
167
// Generated as internal constructor for term eq.
168
pub fn constructor_eq<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
169
    let v4 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg1, arg2);
170
    // Rule at src/prelude_opt.isle line 20.
171
    return v4;
172
}
173

            
174
// Generated as internal constructor for term ne.
175
pub fn constructor_ne<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
176
    let v4 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg1, arg2);
177
    // Rule at src/prelude_opt.isle line 21.
178
    return v4;
179
}
180

            
181
// Generated as internal constructor for term ult.
182
pub fn constructor_ult<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
183
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg1, arg2);
184
    // Rule at src/prelude_opt.isle line 22.
185
    return v4;
186
}
187

            
188
// Generated as internal constructor for term ule.
189
pub fn constructor_ule<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
190
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg1, arg2);
191
    // Rule at src/prelude_opt.isle line 23.
192
    return v4;
193
}
194

            
195
// Generated as internal constructor for term ugt.
196
pub fn constructor_ugt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
197
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg1, arg2);
198
    // Rule at src/prelude_opt.isle line 24.
199
    return v4;
200
}
201

            
202
// Generated as internal constructor for term uge.
203
pub fn constructor_uge<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
204
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg1, arg2);
205
    // Rule at src/prelude_opt.isle line 25.
206
    return v4;
207
}
208

            
209
// Generated as internal constructor for term slt.
210
pub fn constructor_slt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
211
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg1, arg2);
212
    // Rule at src/prelude_opt.isle line 26.
213
    return v4;
214
}
215

            
216
// Generated as internal constructor for term sle.
217
pub fn constructor_sle<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
218
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg1, arg2);
219
    // Rule at src/prelude_opt.isle line 27.
220
    return v4;
221
}
222

            
223
// Generated as internal constructor for term sgt.
224
pub fn constructor_sgt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
225
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg1, arg2);
226
    // Rule at src/prelude_opt.isle line 28.
227
    return v4;
228
}
229

            
230
// Generated as internal constructor for term sge.
231
pub fn constructor_sge<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
232
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg1, arg2);
233
    // Rule at src/prelude_opt.isle line 29.
234
    return v4;
235
}
236

            
237
// Generated as internal constructor for term simplify.
238
pub fn constructor_simplify<C: Context>(
239
    ctx: &mut C,
240
    arg0: Value,
241
) -> impl ContextIter<Context = C, Output = Value> {
242
    let mut returns = ConstructorVec::new();
243
    let v1 = C::inst_data_etor(ctx, arg0);
244
    let mut v1 = v1;
245
    while let Some(v2) = v1.next(ctx) {
246
        match &v2.1 {
247
            &InstructionData::Binary {
248
                opcode: ref v15,
249
                args: ref v16,
250
            } => {
251
                match v15 {
252
                    &Opcode::Iadd => {
253
                        let v17 = C::unpack_value_array_2(ctx, v16);
254
                        let v28 = C::inst_data_etor(ctx, v17.0);
255
                        let mut v28 = v28;
256
                        while let Some(v29) = v28.next(ctx) {
257
                            match &v29.1 {
258
                                &InstructionData::Binary {
259
                                    opcode: ref v70,
260
                                    args: ref v71,
261
                                } => {
262
                                    match v70 {
263
                                        &Opcode::Iadd => {
264
                                            if v2.0 == v29.0 {
265
                                                let v20 = C::inst_data_etor(ctx, v17.1);
266
                                                let mut v20 = v20;
267
                                                while let Some(v21) = v20.next(ctx) {
268
                                                    if let &InstructionData::UnaryImm {
269
                                                        opcode: ref v24,
270
                                                        imm: v25,
271
                                                    } = &v21.1
272
                                                    {
273
                                                        if let &Opcode::Iconst = v24 {
274
                                                            if v2.0 == v21.0 {
275
                                                                let v72 = C::unpack_value_array_2(
276
                                                                    ctx, v71,
277
                                                                );
278
                                                                let v82 =
279
                                                                    C::inst_data_etor(ctx, v72.1);
280
                                                                let mut v82 = v82;
281
                                                                while let Some(v83) = v82.next(ctx)
282
                                                                {
283
                                                                    if let &InstructionData::UnaryImm {
284
                                                                        opcode: ref v86,
285
                                                                        imm: v87,
286
                                                                    } = &v83.1 {
287
                                                                        if let &Opcode::Iconst = v86 {
288
                                                                            if v2.0 == v83.0 {
289
                                                                                let v352 = constructor_iadd(ctx, v2.0, v72.1, v17.1);
290
                                                                                let v353 = constructor_iadd(ctx, v2.0, v72.0, v352);
291
                                                                                // Rule at src/opts/cprop.isle line 122.
292
                                                                                returns.push(v353);
293
                                                                            }
294
                                                                        }
295
                                                                    }
296
                                                                }
297
                                                            }
298
                                                        }
299
                                                    }
300
                                                }
301
                                            }
302
                                        }
303
                                        &Opcode::Isub => {
304
                                            if v2.0 == v29.0 {
305
                                                let v20 = C::inst_data_etor(ctx, v17.1);
306
                                                let mut v20 = v20;
307
                                                while let Some(v21) = v20.next(ctx) {
308
                                                    if let &InstructionData::UnaryImm {
309
                                                        opcode: ref v24,
310
                                                        imm: v25,
311
                                                    } = &v21.1
312
                                                    {
313
                                                        if let &Opcode::Iconst = v24 {
314
                                                            if v2.0 == v21.0 {
315
                                                                let v72 = C::unpack_value_array_2(
316
                                                                    ctx, v71,
317
                                                                );
318
                                                                let v82 =
319
                                                                    C::inst_data_etor(ctx, v72.1);
320
                                                                let mut v82 = v82;
321
                                                                while let Some(v83) = v82.next(ctx)
322
                                                                {
323
                                                                    if let &InstructionData::UnaryImm {
324
                                                                        opcode: ref v86,
325
                                                                        imm: v87,
326
                                                                    } = &v83.1 {
327
                                                                        if let &Opcode::Iconst = v86 {
328
                                                                            if v2.0 == v83.0 {
329
                                                                                let v26 = C::u64_from_imm64(ctx, v25);
330
                                                                                let v88 = C::u64_from_imm64(ctx, v87);
331
                                                                                let v365 = C::u64_sub(ctx, v26, v88);
332
                                                                                let v366 = C::imm64_masked(ctx, v2.0, v365);
333
                                                                                let v367 = constructor_iconst(ctx, v2.0, v366);
334
                                                                                let v369 = constructor_iadd(ctx, v2.0, v72.0, v367);
335
                                                                                // Rule at src/opts/cprop.isle line 144.
336
                                                                                returns.push(v369);
337
                                                                            }
338
                                                                        }
339
                                                                    }
340
                                                                }
341
                                                                let v118 =
342
                                                                    C::inst_data_etor(ctx, v72.0);
343
                                                                let mut v118 = v118;
344
                                                                while let Some(v119) =
345
                                                                    v118.next(ctx)
346
                                                                {
347
                                                                    if let &InstructionData::UnaryImm {
348
                                                                        opcode: ref v358,
349
                                                                        imm: v359,
350
                                                                    } = &v119.1 {
351
                                                                        if let &Opcode::Iconst = v358 {
352
                                                                            if v2.0 == v119.0 {
353
                                                                                let v360 = C::u64_from_imm64(ctx, v359);
354
                                                                                let v26 = C::u64_from_imm64(ctx, v25);
355
                                                                                let v370 = C::u64_add(ctx, v360, v26);
356
                                                                                let v371 = C::imm64_masked(ctx, v2.0, v370);
357
                                                                                let v372 = constructor_iconst(ctx, v2.0, v371);
358
                                                                                let v373 = constructor_isub(ctx, v2.0, v372, v72.1);
359
                                                                                // Rule at src/opts/cprop.isle line 148.
360
                                                                                returns.push(v373);
361
                                                                            }
362
                                                                        }
363
                                                                    }
364
                                                                }
365
                                                            }
366
                                                        }
367
                                                    }
368
                                                }
369
                                            }
370
                                        }
371
                                        _ => {}
372
                                    }
373
                                }
374
                                &InstructionData::UnaryImm {
375
                                    opcode: ref v32,
376
                                    imm: v33,
377
                                } => {
378
                                    if let &Opcode::Iconst = v32 {
379
                                        if v2.0 == v29.0 {
380
                                            let v34 = C::u64_from_imm64(ctx, v33);
381
                                            if v34 == 0x0 {
382
                                                let v35 = C::subsume(ctx, v17.1);
383
                                                // Rule at src/opts/algebraic.isle line 20.
384
                                                returns.push(v35);
385
                                            }
386
                                            let v343 = constructor_iadd(ctx, v2.0, v17.1, v17.0);
387
                                            // Rule at src/opts/cprop.isle line 91.
388
                                            returns.push(v343);
389
                                        }
390
                                        let v46 = C::fits_in_64(ctx, v2.0);
391
                                        if let Some(v47) = v46 {
392
                                            if v29.0 == v47 {
393
                                                let v20 = C::inst_data_etor(ctx, v17.1);
394
                                                let mut v20 = v20;
395
                                                while let Some(v21) = v20.next(ctx) {
396
                                                    if let &InstructionData::UnaryImm {
397
                                                        opcode: ref v24,
398
                                                        imm: v25,
399
                                                    } = &v21.1
400
                                                    {
401
                                                        if let &Opcode::Iconst = v24 {
402
                                                            if v21.0 == v29.0 {
403
                                                                let v34 =
404
                                                                    C::u64_from_imm64(ctx, v33);
405
                                                                let v26 =
406
                                                                    C::u64_from_imm64(ctx, v25);
407
                                                                let v279 =
408
                                                                    C::u64_add(ctx, v34, v26);
409
                                                                let v280 =
410
                                                                    C::imm64_masked(ctx, v47, v279);
411
                                                                let v281 = constructor_iconst(
412
                                                                    ctx, v47, v280,
413
                                                                );
414
                                                                let v282 = C::subsume(ctx, v281);
415
                                                                // Rule at src/opts/cprop.isle line 3.
416
                                                                returns.push(v282);
417
                                                            }
418
                                                        }
419
                                                    }
420
                                                }
421
                                            }
422
                                        }
423
                                        let v138 = C::remat(ctx, arg0);
424
                                        // Rule at src/opts/algebraic.isle line 296.
425
                                        returns.push(v138);
426
                                    }
427
                                }
428
                                _ => {}
429
                            }
430
                        }
431
                        let v20 = C::inst_data_etor(ctx, v17.1);
432
                        let mut v20 = v20;
433
                        while let Some(v21) = v20.next(ctx) {
434
                            if let &InstructionData::UnaryImm {
435
                                opcode: ref v24,
436
                                imm: v25,
437
                            } = &v21.1
438
                            {
439
                                if let &Opcode::Iconst = v24 {
440
                                    let v26 = C::u64_from_imm64(ctx, v25);
441
                                    if v26 == 0x0 {
442
                                        if v2.0 == v21.0 {
443
                                            let v27 = C::subsume(ctx, v17.0);
444
                                            // Rule at src/opts/algebraic.isle line 16.
445
                                            returns.push(v27);
446
                                        }
447
                                    }
448
                                    let v138 = C::remat(ctx, arg0);
449
                                    // Rule at src/opts/algebraic.isle line 298.
450
                                    returns.push(v138);
451
                                }
452
                            }
453
                        }
454
                    }
455
                    &Opcode::Isub => {
456
                        let v17 = C::unpack_value_array_2(ctx, v16);
457
                        let v28 = C::inst_data_etor(ctx, v17.0);
458
                        let mut v28 = v28;
459
                        while let Some(v29) = v28.next(ctx) {
460
                            match &v29.1 {
461
                                &InstructionData::Binary {
462
                                    opcode: ref v70,
463
                                    args: ref v71,
464
                                } => {
465
                                    match v70 {
466
                                        &Opcode::Iadd => {
467
                                            if v2.0 == v29.0 {
468
                                                let v20 = C::inst_data_etor(ctx, v17.1);
469
                                                let mut v20 = v20;
470
                                                while let Some(v21) = v20.next(ctx) {
471
                                                    if let &InstructionData::UnaryImm {
472
                                                        opcode: ref v24,
473
                                                        imm: v25,
474
                                                    } = &v21.1
475
                                                    {
476
                                                        if let &Opcode::Iconst = v24 {
477
                                                            if v2.0 == v21.0 {
478
                                                                let v72 = C::unpack_value_array_2(
479
                                                                    ctx, v71,
480
                                                                );
481
                                                                let v82 =
482
                                                                    C::inst_data_etor(ctx, v72.1);
483
                                                                let mut v82 = v82;
484
                                                                while let Some(v83) = v82.next(ctx)
485
                                                                {
486
                                                                    if let &InstructionData::UnaryImm {
487
                                                                        opcode: ref v86,
488
                                                                        imm: v87,
489
                                                                    } = &v83.1 {
490
                                                                        if let &Opcode::Iconst = v86 {
491
                                                                            if v2.0 == v83.0 {
492
                                                                                let v26 = C::u64_from_imm64(ctx, v25);
493
                                                                                let v88 = C::u64_from_imm64(ctx, v87);
494
                                                                                let v365 = C::u64_sub(ctx, v26, v88);
495
                                                                                let v366 = C::imm64_masked(ctx, v2.0, v365);
496
                                                                                let v367 = constructor_iconst(ctx, v2.0, v366);
497
                                                                                let v368 = constructor_isub(ctx, v2.0, v72.0, v367);
498
                                                                                // Rule at src/opts/cprop.isle line 140.
499
                                                                                returns.push(v368);
500
                                                                            }
501
                                                                        }
502
                                                                    }
503
                                                                }
504
                                                            }
505
                                                        }
506
                                                    }
507
                                                }
508
                                            }
509
                                        }
510
                                        &Opcode::Isub => {
511
                                            if v2.0 == v29.0 {
512
                                                let v20 = C::inst_data_etor(ctx, v17.1);
513
                                                let mut v20 = v20;
514
                                                while let Some(v21) = v20.next(ctx) {
515
                                                    if let &InstructionData::UnaryImm {
516
                                                        opcode: ref v24,
517
                                                        imm: v25,
518
                                                    } = &v21.1
519
                                                    {
520
                                                        if let &Opcode::Iconst = v24 {
521
                                                            if v2.0 == v21.0 {
522
                                                                let v72 = C::unpack_value_array_2(
523
                                                                    ctx, v71,
524
                                                                );
525
                                                                let v82 =
526
                                                                    C::inst_data_etor(ctx, v72.1);
527
                                                                let mut v82 = v82;
528
                                                                while let Some(v83) = v82.next(ctx)
529
                                                                {
530
                                                                    if let &InstructionData::UnaryImm {
531
                                                                        opcode: ref v86,
532
                                                                        imm: v87,
533
                                                                    } = &v83.1 {
534
                                                                        if let &Opcode::Iconst = v86 {
535
                                                                            if v2.0 == v83.0 {
536
                                                                                let v88 = C::u64_from_imm64(ctx, v87);
537
                                                                                let v26 = C::u64_from_imm64(ctx, v25);
538
                                                                                let v354 = C::u64_add(ctx, v88, v26);
539
                                                                                let v355 = C::imm64_masked(ctx, v2.0, v354);
540
                                                                                let v356 = constructor_iconst(ctx, v2.0, v355);
541
                                                                                let v357 = constructor_isub(ctx, v2.0, v72.0, v356);
542
                                                                                // Rule at src/opts/cprop.isle line 132.
543
                                                                                returns.push(v357);
544
                                                                            }
545
                                                                        }
546
                                                                    }
547
                                                                }
548
                                                                let v118 =
549
                                                                    C::inst_data_etor(ctx, v72.0);
550
                                                                let mut v118 = v118;
551
                                                                while let Some(v119) =
552
                                                                    v118.next(ctx)
553
                                                                {
554
                                                                    if let &InstructionData::UnaryImm {
555
                                                                        opcode: ref v358,
556
                                                                        imm: v359,
557
                                                                    } = &v119.1 {
558
                                                                        if let &Opcode::Iconst = v358 {
559
                                                                            if v2.0 == v119.0 {
560
                                                                                let v360 = C::u64_from_imm64(ctx, v359);
561
                                                                                let v26 = C::u64_from_imm64(ctx, v25);
562
                                                                                let v361 = C::u64_sub(ctx, v360, v26);
563
                                                                                let v362 = C::imm64_masked(ctx, v2.0, v361);
564
                                                                                let v363 = constructor_iconst(ctx, v2.0, v362);
565
                                                                                let v364 = constructor_isub(ctx, v2.0, v363, v72.1);
566
                                                                                // Rule at src/opts/cprop.isle line 136.
567
                                                                                returns.push(v364);
568
                                                                            }
569
                                                                        }
570
                                                                    }
571
                                                                }
572
                                                            }
573
                                                        }
574
                                                    }
575
                                                }
576
                                            }
577
                                        }
578
                                        _ => {}
579
                                    }
580
                                }
581
                                &InstructionData::UnaryImm {
582
                                    opcode: ref v32,
583
                                    imm: v33,
584
                                } => {
585
                                    if let &Opcode::Iconst = v32 {
586
                                        if v2.0 == v29.0 {
587
                                            let v34 = C::u64_from_imm64(ctx, v33);
588
                                            if v34 == 0x0 {
589
                                                let v36 = constructor_ineg(ctx, v2.0, v17.1);
590
                                                // Rule at src/opts/algebraic.isle line 30.
591
                                                returns.push(v36);
592
                                            }
593
                                            let v344 = constructor_isub(ctx, v2.0, v17.1, v17.0);
594
                                            let v345 = constructor_ineg(ctx, v2.0, v344);
595
                                            // Rule at src/opts/cprop.isle line 96.
596
                                            returns.push(v345);
597
                                        }
598
                                        let v46 = C::fits_in_64(ctx, v2.0);
599
                                        if let Some(v47) = v46 {
600
                                            if v29.0 == v47 {
601
                                                let v20 = C::inst_data_etor(ctx, v17.1);
602
                                                let mut v20 = v20;
603
                                                while let Some(v21) = v20.next(ctx) {
604
                                                    if let &InstructionData::UnaryImm {
605
                                                        opcode: ref v24,
606
                                                        imm: v25,
607
                                                    } = &v21.1
608
                                                    {
609
                                                        if let &Opcode::Iconst = v24 {
610
                                                            if v21.0 == v29.0 {
611
                                                                let v34 =
612
                                                                    C::u64_from_imm64(ctx, v33);
613
                                                                let v26 =
614
                                                                    C::u64_from_imm64(ctx, v25);
615
                                                                let v283 =
616
                                                                    C::u64_sub(ctx, v34, v26);
617
                                                                let v284 =
618
                                                                    C::imm64_masked(ctx, v47, v283);
619
                                                                let v285 = constructor_iconst(
620
                                                                    ctx, v47, v284,
621
                                                                );
622
                                                                let v286 = C::subsume(ctx, v285);
623
                                                                // Rule at src/opts/cprop.isle line 9.
624
                                                                returns.push(v286);
625
                                                            }
626
                                                        }
627
                                                    }
628
                                                }
629
                                            }
630
                                        }
631
                                        let v138 = C::remat(ctx, arg0);
632
                                        // Rule at src/opts/algebraic.isle line 300.
633
                                        returns.push(v138);
634
                                    }
635
                                }
636
                                _ => {}
637
                            }
638
                        }
639
                        let v20 = C::inst_data_etor(ctx, v17.1);
640
                        let mut v20 = v20;
641
                        while let Some(v21) = v20.next(ctx) {
642
                            if let &InstructionData::UnaryImm {
643
                                opcode: ref v24,
644
                                imm: v25,
645
                            } = &v21.1
646
                            {
647
                                if let &Opcode::Iconst = v24 {
648
                                    let v26 = C::u64_from_imm64(ctx, v25);
649
                                    if v26 == 0x0 {
650
                                        if v2.0 == v21.0 {
651
                                            let v27 = C::subsume(ctx, v17.0);
652
                                            // Rule at src/opts/algebraic.isle line 25.
653
                                            returns.push(v27);
654
                                        }
655
                                    }
656
                                    let v138 = C::remat(ctx, arg0);
657
                                    // Rule at src/opts/algebraic.isle line 302.
658
                                    returns.push(v138);
659
                                }
660
                            }
661
                        }
662
                        if v17.0 == v17.1 {
663
                            let v46 = C::fits_in_64(ctx, v2.0);
664
                            if let Some(v47) = v46 {
665
                                let v48 = C::ty_int(ctx, v47);
666
                                if let Some(v49) = v48 {
667
                                    let v51 = C::imm64(ctx, 0x0);
668
                                    let v52 = constructor_iconst(ctx, v49, v51);
669
                                    let v53 = C::subsume(ctx, v52);
670
                                    // Rule at src/opts/algebraic.isle line 51.
671
                                    returns.push(v53);
672
                                }
673
                            }
674
                        }
675
                    }
676
                    &Opcode::Imul => {
677
                        let v17 = C::unpack_value_array_2(ctx, v16);
678
                        let v28 = C::inst_data_etor(ctx, v17.0);
679
                        let mut v28 = v28;
680
                        while let Some(v29) = v28.next(ctx) {
681
                            match &v29.1 {
682
                                &InstructionData::Binary {
683
                                    opcode: ref v70,
684
                                    args: ref v71,
685
                                } => {
686
                                    if let &Opcode::Imul = v70 {
687
                                        if v2.0 == v29.0 {
688
                                            let v20 = C::inst_data_etor(ctx, v17.1);
689
                                            let mut v20 = v20;
690
                                            while let Some(v21) = v20.next(ctx) {
691
                                                if let &InstructionData::UnaryImm {
692
                                                    opcode: ref v24,
693
                                                    imm: v25,
694
                                                } = &v21.1
695
                                                {
696
                                                    if let &Opcode::Iconst = v24 {
697
                                                        if v2.0 == v21.0 {
698
                                                            let v72 =
699
                                                                C::unpack_value_array_2(ctx, v71);
700
                                                            let v82 = C::inst_data_etor(ctx, v72.1);
701
                                                            let mut v82 = v82;
702
                                                            while let Some(v83) = v82.next(ctx) {
703
                                                                if let &InstructionData::UnaryImm {
704
                                                                    opcode: ref v86,
705
                                                                    imm: v87,
706
                                                                } = &v83.1 {
707
                                                                    if let &Opcode::Iconst = v86 {
708
                                                                        if v2.0 == v83.0 {
709
                                                                            let v374 = constructor_imul(ctx, v2.0, v72.1, v17.1);
710
                                                                            let v375 = constructor_imul(ctx, v2.0, v72.0, v374);
711
                                                                            // Rule at src/opts/cprop.isle line 153.
712
                                                                            returns.push(v375);
713
                                                                        }
714
                                                                    }
715
                                                                }
716
                                                            }
717
                                                        }
718
                                                    }
719
                                                }
720
                                            }
721
                                        }
722
                                    }
723
                                }
724
                                &InstructionData::Unary {
725
                                    opcode: ref v38,
726
                                    arg: v39,
727
                                } => {
728
                                    if let &Opcode::Ineg = v38 {
729
                                        if v2.0 == v29.0 {
730
                                            let v20 = C::inst_data_etor(ctx, v17.1);
731
                                            let mut v20 = v20;
732
                                            while let Some(v21) = v20.next(ctx) {
733
                                                if let &InstructionData::Unary {
734
                                                    opcode: ref v40,
735
                                                    arg: v41,
736
                                                } = &v21.1
737
                                                {
738
                                                    if let &Opcode::Ineg = v40 {
739
                                                        if v2.0 == v21.0 {
740
                                                            let v42 = constructor_imul(
741
                                                                ctx, v2.0, v39, v41,
742
                                                            );
743
                                                            let v43 = C::subsume(ctx, v42);
744
                                                            // Rule at src/opts/algebraic.isle line 39.
745
                                                            returns.push(v43);
746
                                                        }
747
                                                    }
748
                                                }
749
                                            }
750
                                        }
751
                                    }
752
                                }
753
                                &InstructionData::UnaryImm {
754
                                    opcode: ref v32,
755
                                    imm: v33,
756
                                } => {
757
                                    if let &Opcode::Iconst = v32 {
758
                                        if v2.0 == v29.0 {
759
                                            let v34 = C::u64_from_imm64(ctx, v33);
760
                                            match v34 {
761
                                                0x0 => {
762
                                                    let v27 = C::subsume(ctx, v17.0);
763
                                                    // Rule at src/opts/algebraic.isle line 68.
764
                                                    returns.push(v27);
765
                                                }
766
                                                0x1 => {
767
                                                    let v35 = C::subsume(ctx, v17.1);
768
                                                    // Rule at src/opts/algebraic.isle line 58.
769
                                                    returns.push(v35);
770
                                                }
771
                                                _ => {}
772
                                            }
773
                                            let v56 = C::i64_sextend_imm64(ctx, v2.0, v33);
774
                                            if v56 == -0x1 {
775
                                                let v36 = constructor_ineg(ctx, v2.0, v17.1);
776
                                                // Rule at src/opts/algebraic.isle line 77.
777
                                                returns.push(v36);
778
                                            }
779
                                            let v346 = constructor_imul(ctx, v2.0, v17.1, v17.0);
780
                                            // Rule at src/opts/cprop.isle line 99.
781
                                            returns.push(v346);
782
                                        }
783
                                        let v46 = C::fits_in_64(ctx, v2.0);
784
                                        if let Some(v47) = v46 {
785
                                            if v29.0 == v47 {
786
                                                let v20 = C::inst_data_etor(ctx, v17.1);
787
                                                let mut v20 = v20;
788
                                                while let Some(v21) = v20.next(ctx) {
789
                                                    if let &InstructionData::UnaryImm {
790
                                                        opcode: ref v24,
791
                                                        imm: v25,
792
                                                    } = &v21.1
793
                                                    {
794
                                                        if let &Opcode::Iconst = v24 {
795
                                                            if v21.0 == v29.0 {
796
                                                                let v34 =
797
                                                                    C::u64_from_imm64(ctx, v33);
798
                                                                let v26 =
799
                                                                    C::u64_from_imm64(ctx, v25);
800
                                                                let v287 =
801
                                                                    C::u64_mul(ctx, v34, v26);
802
                                                                let v288 =
803
                                                                    C::imm64_masked(ctx, v47, v287);
804
                                                                let v289 = constructor_iconst(
805
                                                                    ctx, v47, v288,
806
                                                                );
807
                                                                let v290 = C::subsume(ctx, v289);
808
                                                                // Rule at src/opts/cprop.isle line 15.
809
                                                                returns.push(v290);
810
                                                            }
811
                                                        }
812
                                                    }
813
                                                }
814
                                            }
815
                                        }
816
                                        let v97 = C::simm32(ctx, v33);
817
                                        if let Some(v98) = v97 {
818
                                            if v98 == 0x2 {
819
                                                let v99 = constructor_iadd(ctx, v2.0, v17.1, v17.1);
820
                                                // Rule at src/opts/algebraic.isle line 204.
821
                                                returns.push(v99);
822
                                            }
823
                                        }
824
                                        let v105 = C::imm64_power_of_two(ctx, v33);
825
                                        if let Some(v106) = v105 {
826
                                            let v107 = C::imm64(ctx, v106);
827
                                            let v108 = constructor_iconst(ctx, v2.0, v107);
828
                                            let v109 = constructor_ishl(ctx, v2.0, v17.1, v108);
829
                                            // Rule at src/opts/algebraic.isle line 213.
830
                                            returns.push(v109);
831
                                        }
832
                                    }
833
                                }
834
                                _ => {}
835
                            }
836
                        }
837
                        let v20 = C::inst_data_etor(ctx, v17.1);
838
                        let mut v20 = v20;
839
                        while let Some(v21) = v20.next(ctx) {
840
                            if let &InstructionData::UnaryImm {
841
                                opcode: ref v24,
842
                                imm: v25,
843
                            } = &v21.1
844
                            {
845
                                if let &Opcode::Iconst = v24 {
846
                                    if v2.0 == v21.0 {
847
                                        let v26 = C::u64_from_imm64(ctx, v25);
848
                                        match v26 {
849
                                            0x0 => {
850
                                                let v35 = C::subsume(ctx, v17.1);
851
                                                // Rule at src/opts/algebraic.isle line 64.
852
                                                returns.push(v35);
853
                                            }
854
                                            0x1 => {
855
                                                let v27 = C::subsume(ctx, v17.0);
856
                                                // Rule at src/opts/algebraic.isle line 54.
857
                                                returns.push(v27);
858
                                            }
859
                                            _ => {}
860
                                        }
861
                                        let v54 = C::i64_sextend_imm64(ctx, v2.0, v25);
862
                                        if v54 == -0x1 {
863
                                            let v55 = constructor_ineg(ctx, v2.0, v17.0);
864
                                            // Rule at src/opts/algebraic.isle line 74.
865
                                            returns.push(v55);
866
                                        }
867
                                    }
868
                                    let v94 = C::simm32(ctx, v25);
869
                                    if let Some(v95) = v94 {
870
                                        if v95 == 0x2 {
871
                                            let v96 = constructor_iadd(ctx, v2.0, v17.0, v17.0);
872
                                            // Rule at src/opts/algebraic.isle line 202.
873
                                            returns.push(v96);
874
                                        }
875
                                    }
876
                                    let v100 = C::imm64_power_of_two(ctx, v25);
877
                                    if let Some(v101) = v100 {
878
                                        let v102 = C::imm64(ctx, v101);
879
                                        let v103 = constructor_iconst(ctx, v2.0, v102);
880
                                        let v104 = constructor_ishl(ctx, v2.0, v17.0, v103);
881
                                        // Rule at src/opts/algebraic.isle line 211.
882
                                        returns.push(v104);
883
                                    }
884
                                }
885
                            }
886
                        }
887
                    }
888
                    &Opcode::Udiv => {
889
                        let v17 = C::unpack_value_array_2(ctx, v16);
890
                        let v20 = C::inst_data_etor(ctx, v17.1);
891
                        let mut v20 = v20;
892
                        while let Some(v21) = v20.next(ctx) {
893
                            if let &InstructionData::UnaryImm {
894
                                opcode: ref v24,
895
                                imm: v25,
896
                            } = &v21.1
897
                            {
898
                                if let &Opcode::Iconst = v24 {
899
                                    let v26 = C::u64_from_imm64(ctx, v25);
900
                                    if v26 == 0x1 {
901
                                        if v2.0 == v21.0 {
902
                                            let v27 = C::subsume(ctx, v17.0);
903
                                            // Rule at src/opts/algebraic.isle line 86.
904
                                            returns.push(v27);
905
                                        }
906
                                    }
907
                                    let v46 = C::fits_in_64(ctx, v2.0);
908
                                    if let Some(v47) = v46 {
909
                                        if v21.0 == v47 {
910
                                            let v28 = C::inst_data_etor(ctx, v17.0);
911
                                            let mut v28 = v28;
912
                                            while let Some(v29) = v28.next(ctx) {
913
                                                if let &InstructionData::UnaryImm {
914
                                                    opcode: ref v32,
915
                                                    imm: v33,
916
                                                } = &v29.1
917
                                                {
918
                                                    if let &Opcode::Iconst = v32 {
919
                                                        let v34 = C::u64_from_imm64(ctx, v33);
920
                                                        let v296 = C::u64_udiv(ctx, v34, v26);
921
                                                        if let Some(v297) = v296 {
922
                                                            if v21.0 == v29.0 {
923
                                                                let v298 =
924
                                                                    C::imm64_masked(ctx, v47, v297);
925
                                                                let v299 = constructor_iconst(
926
                                                                    ctx, v47, v298,
927
                                                                );
928
                                                                let v300 = C::subsume(ctx, v299);
929
                                                                // Rule at src/opts/cprop.isle line 28.
930
                                                                returns.push(v300);
931
                                                            }
932
                                                        }
933
                                                    }
934
                                                }
935
                                            }
936
                                        }
937
                                    }
938
                                }
939
                            }
940
                        }
941
                    }
942
                    &Opcode::Sdiv => {
943
                        let v17 = C::unpack_value_array_2(ctx, v16);
944
                        let v20 = C::inst_data_etor(ctx, v17.1);
945
                        let mut v20 = v20;
946
                        while let Some(v21) = v20.next(ctx) {
947
                            if let &InstructionData::UnaryImm {
948
                                opcode: ref v24,
949
                                imm: v25,
950
                            } = &v21.1
951
                            {
952
                                if let &Opcode::Iconst = v24 {
953
                                    let v26 = C::u64_from_imm64(ctx, v25);
954
                                    if v26 == 0x1 {
955
                                        if v2.0 == v21.0 {
956
                                            let v27 = C::subsume(ctx, v17.0);
957
                                            // Rule at src/opts/algebraic.isle line 82.
958
                                            returns.push(v27);
959
                                        }
960
                                    }
961
                                    let v46 = C::fits_in_64(ctx, v2.0);
962
                                    if let Some(v47) = v46 {
963
                                        if v21.0 == v47 {
964
                                            let v28 = C::inst_data_etor(ctx, v17.0);
965
                                            let mut v28 = v28;
966
                                            while let Some(v29) = v28.next(ctx) {
967
                                                if let &InstructionData::UnaryImm {
968
                                                    opcode: ref v32,
969
                                                    imm: v33,
970
                                                } = &v29.1
971
                                                {
972
                                                    if let &Opcode::Iconst = v32 {
973
                                                        let v34 = C::u64_from_imm64(ctx, v33);
974
                                                        let v291 = C::u64_sdiv(ctx, v34, v26);
975
                                                        if let Some(v292) = v291 {
976
                                                            if v21.0 == v29.0 {
977
                                                                let v293 =
978
                                                                    C::imm64_masked(ctx, v47, v292);
979
                                                                let v294 = constructor_iconst(
980
                                                                    ctx, v47, v293,
981
                                                                );
982
                                                                let v295 = C::subsume(ctx, v294);
983
                                                                // Rule at src/opts/cprop.isle line 21.
984
                                                                returns.push(v295);
985
                                                            }
986
                                                        }
987
                                                    }
988
                                                }
989
                                            }
990
                                        }
991
                                    }
992
                                }
993
                            }
994
                        }
995
                    }
996
                    &Opcode::Band => {
997
                        let v17 = C::unpack_value_array_2(ctx, v16);
998
                        let v28 = C::inst_data_etor(ctx, v17.0);
999
                        let mut v28 = v28;
                        while let Some(v29) = v28.next(ctx) {
                            match &v29.1 {
                                &InstructionData::Binary {
                                    opcode: ref v70,
                                    args: ref v71,
                                } => {
                                    if let &Opcode::Band = v70 {
                                        if v2.0 == v29.0 {
                                            let v20 = C::inst_data_etor(ctx, v17.1);
                                            let mut v20 = v20;
                                            while let Some(v21) = v20.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v24,
                                                    imm: v25,
                                                } = &v21.1
                                                {
                                                    if let &Opcode::Iconst = v24 {
                                                        if v2.0 == v21.0 {
                                                            let v72 =
                                                                C::unpack_value_array_2(ctx, v71);
                                                            let v82 = C::inst_data_etor(ctx, v72.1);
                                                            let mut v82 = v82;
                                                            while let Some(v83) = v82.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v86,
                                                                    imm: v87,
                                                                } = &v83.1 {
                                                                    if let &Opcode::Iconst = v86 {
                                                                        if v2.0 == v83.0 {
                                                                            let v378 = constructor_band(ctx, v2.0, v72.1, v17.1);
                                                                            let v379 = constructor_band(ctx, v2.0, v72.0, v378);
                                                                            // Rule at src/opts/cprop.isle line 159.
                                                                            returns.push(v379);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v240,
                                    args: ref v241,
                                    cond: ref v242,
                                } => {
                                    if let &Opcode::Icmp = v240 {
                                        let v20 = C::inst_data_etor(ctx, v17.1);
                                        let mut v20 = v20;
                                        while let Some(v21) = v20.next(ctx) {
                                            match &v21.1 {
                                                &InstructionData::IntCompare {
                                                    opcode: ref v265,
                                                    args: ref v266,
                                                    cond: ref v267,
                                                } => {
                                                    if let &Opcode::Icmp = v265 {
                                                        let v271 = constructor_intcc_comparable(
                                                            ctx, v242, v267,
                                                        );
                                                        if let Some(v272) = v271 {
                                                            if v2.0 == v21.0 {
                                                                if v2.0 == v29.0 {
                                                                    let v243 =
                                                                        C::unpack_value_array_2(
                                                                            ctx, v241,
                                                                        );
                                                                    let v268 =
                                                                        C::unpack_value_array_2(
                                                                            ctx, v266,
                                                                        );
                                                                    if v243.0 == v268.0 {
                                                                        if v243.1 == v268.1 {
                                                                            let v273 = constructor_decompose_intcc(ctx, v242);
                                                                            let v274 = constructor_decompose_intcc(ctx, v267);
                                                                            let v275 = C::u64_and(
                                                                                ctx, v273, v274,
                                                                            );
                                                                            let v276 = constructor_compose_icmp(ctx, v2.0, v275, v272, v243.0, v243.1);
                                                                            // Rule at src/opts/icmp.isle line 128.
                                                                            returns.push(v276);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v24,
                                                    imm: v25,
                                                } => {
                                                    if let &Opcode::Iconst = v24 {
                                                        let v26 = C::u64_from_imm64(ctx, v25);
                                                        if v26 == 0x1 {
                                                            let v238 = C::ty_int(ctx, v2.0);
                                                            if let Some(v239) = v238 {
                                                                // Rule at src/opts/icmp.isle line 39.
                                                                returns.push(v17.0);
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v38,
                                    arg: v39,
                                } => {
                                    match v38 {
                                        &Opcode::Bnot => {
                                            let v46 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v47) = v46 {
                                                let v48 = C::ty_int(ctx, v47);
                                                if let Some(v49) = v48 {
                                                    if v17.1 == v39 {
                                                        if v29.0 == v49 {
                                                            let v51 = C::imm64(ctx, 0x0);
                                                            let v52 =
                                                                constructor_iconst(ctx, v49, v51);
                                                            let v53 = C::subsume(ctx, v52);
                                                            // Rule at src/opts/algebraic.isle line 160.
                                                            returns.push(v53);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v20 = C::inst_data_etor(ctx, v17.1);
                                            let mut v20 = v20;
                                            while let Some(v21) = v20.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v24,
                                                    imm: v25,
                                                } = &v21.1
                                                {
                                                    if let &Opcode::Iconst = v24 {
                                                        let v26 = C::u64_from_imm64(ctx, v25);
                                                        if v26 == 0x1 {
                                                            let v238 = C::ty_int(ctx, v2.0);
                                                            if let Some(v239) = v238 {
                                                                let v246 =
                                                                    C::inst_data_etor(ctx, v39);
                                                                let mut v246 = v246;
                                                                while let Some(v247) =
                                                                    v246.next(ctx)
                                                                {
                                                                    if let &InstructionData::IntCompare {
                                                                        opcode: ref v250,
                                                                        args: ref v251,
                                                                        cond: ref v252,
                                                                    } = &v247.1 {
                                                                        if let &Opcode::Icmp = v250 {
                                                                            // Rule at src/opts/icmp.isle line 44.
                                                                            returns.push(v17.0);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        let v132 = C::value_type(ctx, v39);
                                                        let v133 = C::ty_mask(ctx, v132);
                                                        let v134 = C::u64_and(ctx, v26, v133);
                                                        let v135 = C::u64_eq(ctx, v133, v134);
                                                        if v135 == true {
                                                            // Rule at src/opts/algebraic.isle line 282.
                                                            returns.push(v17.0);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            let v20 = C::inst_data_etor(ctx, v17.1);
                                            let mut v20 = v20;
                                            while let Some(v21) = v20.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v24,
                                                    imm: v25,
                                                } = &v21.1
                                                {
                                                    if let &Opcode::Iconst = v24 {
                                                        let v26 = C::u64_from_imm64(ctx, v25);
                                                        let v132 = C::value_type(ctx, v39);
                                                        let v133 = C::ty_mask(ctx, v132);
                                                        let v136 = C::u64_eq(ctx, v26, v133);
                                                        if v136 == true {
                                                            let v137 =
                                                                constructor_uextend(ctx, v2.0, v39);
                                                            // Rule at src/opts/algebraic.isle line 288.
                                                            returns.push(v137);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v32,
                                    imm: v33,
                                } => {
                                    if let &Opcode::Iconst = v32 {
                                        if v2.0 == v29.0 {
                                            let v34 = C::u64_from_imm64(ctx, v33);
                                            if v34 == 0x0 {
                                                let v27 = C::subsume(ctx, v17.0);
                                                // Rule at src/opts/algebraic.isle line 158.
                                                returns.push(v27);
                                            }
                                            let v56 = C::i64_sextend_imm64(ctx, v2.0, v33);
                                            if v56 == -0x1 {
                                                let v35 = C::subsume(ctx, v17.1);
                                                // Rule at src/opts/algebraic.isle line 152.
                                                returns.push(v35);
                                            }
                                            let v348 = constructor_band(ctx, v2.0, v17.1, v17.0);
                                            // Rule at src/opts/cprop.isle line 106.
                                            returns.push(v348);
                                        }
                                        let v46 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v47) = v46 {
                                            if v29.0 == v47 {
                                                let v20 = C::inst_data_etor(ctx, v17.1);
                                                let mut v20 = v20;
                                                while let Some(v21) = v20.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v24,
                                                        imm: v25,
                                                    } = &v21.1
                                                    {
                                                        if let &Opcode::Iconst = v24 {
                                                            if v21.0 == v29.0 {
                                                                let v34 =
                                                                    C::u64_from_imm64(ctx, v33);
                                                                let v26 =
                                                                    C::u64_from_imm64(ctx, v25);
                                                                let v305 =
                                                                    C::u64_and(ctx, v34, v26);
                                                                let v306 =
                                                                    C::imm64_masked(ctx, v47, v305);
                                                                let v307 = constructor_iconst(
                                                                    ctx, v47, v306,
                                                                );
                                                                let v308 = C::subsume(ctx, v307);
                                                                // Rule at src/opts/cprop.isle line 41.
                                                                returns.push(v308);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v138 = C::remat(ctx, arg0);
                                        // Rule at src/opts/algebraic.isle line 304.
                                        returns.push(v138);
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v20 = C::inst_data_etor(ctx, v17.1);
                        let mut v20 = v20;
                        while let Some(v21) = v20.next(ctx) {
                            match &v21.1 {
                                &InstructionData::Unary {
                                    opcode: ref v40,
                                    arg: v41,
                                } => {
                                    if let &Opcode::Bnot = v40 {
                                        if v17.0 == v41 {
                                            let v46 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v47) = v46 {
                                                let v48 = C::ty_int(ctx, v47);
                                                if let Some(v49) = v48 {
                                                    if v21.0 == v49 {
                                                        let v51 = C::imm64(ctx, 0x0);
                                                        let v52 = constructor_iconst(ctx, v49, v51);
                                                        let v53 = C::subsume(ctx, v52);
                                                        // Rule at src/opts/algebraic.isle line 159.
                                                        returns.push(v53);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v24,
                                    imm: v25,
                                } => {
                                    if let &Opcode::Iconst = v24 {
                                        if v2.0 == v21.0 {
                                            let v26 = C::u64_from_imm64(ctx, v25);
                                            if v26 == 0x0 {
                                                let v35 = C::subsume(ctx, v17.1);
                                                // Rule at src/opts/algebraic.isle line 157.
                                                returns.push(v35);
                                            }
                                            let v54 = C::i64_sextend_imm64(ctx, v2.0, v25);
                                            if v54 == -0x1 {
                                                let v27 = C::subsume(ctx, v17.0);
                                                // Rule at src/opts/algebraic.isle line 149.
                                                returns.push(v27);
                                            }
                                        }
                                        let v138 = C::remat(ctx, arg0);
                                        // Rule at src/opts/algebraic.isle line 306.
                                        returns.push(v138);
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v17.0 == v17.1 {
                            let v27 = C::subsume(ctx, v17.0);
                            // Rule at src/opts/algebraic.isle line 148.
                            returns.push(v27);
                        }
                    }
                    &Opcode::Bor => {
                        let v17 = C::unpack_value_array_2(ctx, v16);
                        let v28 = C::inst_data_etor(ctx, v17.0);
                        let mut v28 = v28;
                        while let Some(v29) = v28.next(ctx) {
                            match &v29.1 {
                                &InstructionData::Binary {
                                    opcode: ref v70,
                                    args: ref v71,
                                } => {
                                    match v70 {
                                        &Opcode::Band => {
                                            if v2.0 == v29.0 {
                                                let v20 = C::inst_data_etor(ctx, v17.1);
                                                let mut v20 = v20;
                                                while let Some(v21) = v20.next(ctx) {
                                                    match &v21.1 {
                                                        &InstructionData::Unary {
                                                            opcode: ref v40,
                                                            arg: v41,
                                                        } => {
                                                            if let &Opcode::Bnot = v40 {
                                                                if v2.0 == v21.0 {
                                                                    let v72 =
                                                                        C::unpack_value_array_2(
                                                                            ctx, v71,
                                                                        );
                                                                    if v41 == v72.1 {
                                                                        let v75 = constructor_bor(
                                                                            ctx, v2.0, v72.0, v17.1,
                                                                        );
                                                                        // Rule at src/opts/algebraic.isle line 174.
                                                                        returns.push(v75);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v24,
                                                            imm: v25,
                                                        } => {
                                                            if let &Opcode::Iconst = v24 {
                                                                if v2.0 == v21.0 {
                                                                    let v72 =
                                                                        C::unpack_value_array_2(
                                                                            ctx, v71,
                                                                        );
                                                                    let v82 = C::inst_data_etor(
                                                                        ctx, v72.1,
                                                                    );
                                                                    let mut v82 = v82;
                                                                    while let Some(v83) =
                                                                        v82.next(ctx)
                                                                    {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v86,
                                                                            imm: v87,
                                                                        } = &v83.1 {
                                                                            if let &Opcode::Iconst = v86 {
                                                                                let v89 = C::ty_mask(ctx, v2.0);
                                                                                let v26 = C::u64_from_imm64(ctx, v25);
                                                                                let v90 = C::u64_and(ctx, v89, v26);
                                                                                let v88 = C::u64_from_imm64(ctx, v87);
                                                                                let v91 = C::u64_not(ctx, v88);
                                                                                let v92 = C::u64_and(ctx, v89, v91);
                                                                                let v93 = C::u64_eq(ctx, v90, v92);
                                                                                if v93 == true {
                                                                                    if v2.0 == v83.0 {
                                                                                        let v75 = constructor_bor(ctx, v2.0, v72.0, v17.1);
                                                                                        // Rule at src/opts/algebraic.isle line 194.
                                                                                        returns.push(v75);
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v29.0 {
                                                let v20 = C::inst_data_etor(ctx, v17.1);
                                                let mut v20 = v20;
                                                while let Some(v21) = v20.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v24,
                                                        imm: v25,
                                                    } = &v21.1
                                                    {
                                                        if let &Opcode::Iconst = v24 {
                                                            if v2.0 == v21.0 {
                                                                let v72 = C::unpack_value_array_2(
                                                                    ctx, v71,
                                                                );
                                                                let v82 =
                                                                    C::inst_data_etor(ctx, v72.1);
                                                                let mut v82 = v82;
                                                                while let Some(v83) = v82.next(ctx)
                                                                {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v86,
                                                                        imm: v87,
                                                                    } = &v83.1 {
                                                                        if let &Opcode::Iconst = v86 {
                                                                            if v2.0 == v83.0 {
                                                                                let v376 = constructor_bor(ctx, v2.0, v72.1, v17.1);
                                                                                let v377 = constructor_bor(ctx, v2.0, v72.0, v376);
                                                                                // Rule at src/opts/cprop.isle line 156.
                                                                                returns.push(v377);
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v240,
                                    args: ref v241,
                                    cond: ref v242,
                                } => {
                                    if let &Opcode::Icmp = v240 {
                                        if v2.0 == v29.0 {
                                            let v20 = C::inst_data_etor(ctx, v17.1);
                                            let mut v20 = v20;
                                            while let Some(v21) = v20.next(ctx) {
                                                if let &InstructionData::IntCompare {
                                                    opcode: ref v265,
                                                    args: ref v266,
                                                    cond: ref v267,
                                                } = &v21.1
                                                {
                                                    if let &Opcode::Icmp = v265 {
                                                        let v271 = constructor_intcc_comparable(
                                                            ctx, v242, v267,
                                                        );
                                                        if let Some(v272) = v271 {
                                                            if v2.0 == v21.0 {
                                                                let v243 = C::unpack_value_array_2(
                                                                    ctx, v241,
                                                                );
                                                                let v268 = C::unpack_value_array_2(
                                                                    ctx, v266,
                                                                );
                                                                if v243.0 == v268.0 {
                                                                    if v243.1 == v268.1 {
                                                                        let v273 = constructor_decompose_intcc(ctx, v242);
                                                                        let v274 = constructor_decompose_intcc(ctx, v267);
                                                                        let v277 = C::u64_or(
                                                                            ctx, v273, v274,
                                                                        );
                                                                        let v278 = constructor_compose_icmp(ctx, v2.0, v277, v272, v243.0, v243.1);
                                                                        // Rule at src/opts/icmp.isle line 132.
                                                                        returns.push(v278);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v38,
                                    arg: v39,
                                } => {
                                    if let &Opcode::Bnot = v38 {
                                        let v46 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v47) = v46 {
                                            let v48 = C::ty_int(ctx, v47);
                                            if let Some(v49) = v48 {
                                                if v17.1 == v39 {
                                                    if v29.0 == v49 {
                                                        let v57 = C::ty_mask(ctx, v49);
                                                        let v58 = C::imm64(ctx, v57);
                                                        let v59 = constructor_iconst(ctx, v49, v58);
                                                        let v60 = C::subsume(ctx, v59);
                                                        // Rule at src/opts/algebraic.isle line 145.
                                                        returns.push(v60);
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v29.0 {
                                            let v20 = C::inst_data_etor(ctx, v17.1);
                                            let mut v20 = v20;
                                            while let Some(v21) = v20.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v76,
                                                    args: ref v77,
                                                } = &v21.1
                                                {
                                                    if let &Opcode::Band = v76 {
                                                        if v2.0 == v21.0 {
                                                            let v78 =
                                                                C::unpack_value_array_2(ctx, v77);
                                                            if v39 == v78.1 {
                                                                let v81 = constructor_bor(
                                                                    ctx, v2.0, v78.0, v17.0,
                                                                );
                                                                // Rule at src/opts/algebraic.isle line 183.
                                                                returns.push(v81);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v32,
                                    imm: v33,
                                } => {
                                    if let &Opcode::Iconst = v32 {
                                        if v2.0 == v29.0 {
                                            let v34 = C::u64_from_imm64(ctx, v33);
                                            if v34 == 0x0 {
                                                let v35 = C::subsume(ctx, v17.1);
                                                // Rule at src/opts/algebraic.isle line 118.
                                                returns.push(v35);
                                            }
                                            let v347 = constructor_bor(ctx, v2.0, v17.1, v17.0);
                                            // Rule at src/opts/cprop.isle line 103.
                                            returns.push(v347);
                                        }
                                        let v46 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v47) = v46 {
                                            if v29.0 == v47 {
                                                let v20 = C::inst_data_etor(ctx, v17.1);
                                                let mut v20 = v20;
                                                while let Some(v21) = v20.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v24,
                                                        imm: v25,
                                                    } = &v21.1
                                                    {
                                                        if let &Opcode::Iconst = v24 {
                                                            if v21.0 == v29.0 {
                                                                let v34 =
                                                                    C::u64_from_imm64(ctx, v33);
                                                                let v26 =
                                                                    C::u64_from_imm64(ctx, v25);
                                                                let v301 = C::u64_or(ctx, v34, v26);
                                                                let v302 =
                                                                    C::imm64_masked(ctx, v47, v301);
                                                                let v303 = constructor_iconst(
                                                                    ctx, v47, v302,
                                                                );
                                                                let v304 = C::subsume(ctx, v303);
                                                                // Rule at src/opts/cprop.isle line 35.
                                                                returns.push(v304);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v138 = C::remat(ctx, arg0);
                                        // Rule at src/opts/algebraic.isle line 308.
                                        returns.push(v138);
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v20 = C::inst_data_etor(ctx, v17.1);
                        let mut v20 = v20;
                        while let Some(v21) = v20.next(ctx) {
                            match &v21.1 {
                                &InstructionData::Unary {
                                    opcode: ref v40,
                                    arg: v41,
                                } => {
                                    if let &Opcode::Bnot = v40 {
                                        if v17.0 == v41 {
                                            let v46 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v47) = v46 {
                                                let v48 = C::ty_int(ctx, v47);
                                                if let Some(v49) = v48 {
                                                    if v21.0 == v49 {
                                                        let v57 = C::ty_mask(ctx, v49);
                                                        let v58 = C::imm64(ctx, v57);
                                                        let v59 = constructor_iconst(ctx, v49, v58);
                                                        let v60 = C::subsume(ctx, v59);
                                                        // Rule at src/opts/algebraic.isle line 144.
                                                        returns.push(v60);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v24,
                                    imm: v25,
                                } => {
                                    if let &Opcode::Iconst = v24 {
                                        let v26 = C::u64_from_imm64(ctx, v25);
                                        if v26 == 0x0 {
                                            if v2.0 == v21.0 {
                                                let v27 = C::subsume(ctx, v17.0);
                                                // Rule at src/opts/algebraic.isle line 114.
                                                returns.push(v27);
                                            }
                                        }
                                        let v138 = C::remat(ctx, arg0);
                                        // Rule at src/opts/algebraic.isle line 310.
                                        returns.push(v138);
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v17.0 == v17.1 {
                            let v27 = C::subsume(ctx, v17.0);
                            // Rule at src/opts/algebraic.isle line 122.
                            returns.push(v27);
                        }
                    }
                    &Opcode::Bxor => {
                        let v17 = C::unpack_value_array_2(ctx, v16);
                        let v20 = C::inst_data_etor(ctx, v17.1);
                        let mut v20 = v20;
                        while let Some(v21) = v20.next(ctx) {
                            match &v21.1 {
                                &InstructionData::Unary {
                                    opcode: ref v40,
                                    arg: v41,
                                } => {
                                    if let &Opcode::Bnot = v40 {
                                        let v46 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v47) = v46 {
                                            let v48 = C::ty_int(ctx, v47);
                                            if let Some(v49) = v48 {
                                                if v17.0 == v41 {
                                                    if v21.0 == v49 {
                                                        let v57 = C::ty_mask(ctx, v49);
                                                        let v58 = C::imm64(ctx, v57);
                                                        let v59 = constructor_iconst(ctx, v49, v58);
                                                        let v60 = C::subsume(ctx, v59);
                                                        // Rule at src/opts/algebraic.isle line 142.
                                                        returns.push(v60);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v24,
                                    imm: v25,
                                } => {
                                    if let &Opcode::Iconst = v24 {
                                        if v2.0 == v21.0 {
                                            let v26 = C::u64_from_imm64(ctx, v25);
                                            if v26 == 0x0 {
                                                let v27 = C::subsume(ctx, v17.0);
                                                // Rule at src/opts/algebraic.isle line 126.
                                                returns.push(v27);
                                            }
                                            let v54 = C::i64_sextend_imm64(ctx, v2.0, v25);
                                            if v54 == -0x1 {
                                                let v145 = constructor_bnot(ctx, v2.0, v17.0);
                                                // Rule at src/opts/algebraic.isle line 326.
                                                returns.push(v145);
                                            }
                                            let v28 = C::inst_data_etor(ctx, v17.0);
                                            let mut v28 = v28;
                                            while let Some(v29) = v28.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v70,
                                                    args: ref v71,
                                                } = &v29.1
                                                {
                                                    if let &Opcode::Bxor = v70 {
                                                        if v2.0 == v29.0 {
                                                            let v72 =
                                                                C::unpack_value_array_2(ctx, v71);
                                                            let v82 = C::inst_data_etor(ctx, v72.1);
                                                            let mut v82 = v82;
                                                            while let Some(v83) = v82.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v86,
                                                                    imm: v87,
                                                                } = &v83.1 {
                                                                    if let &Opcode::Iconst = v86 {
                                                                        if v2.0 == v83.0 {
                                                                            let v380 = constructor_bxor(ctx, v2.0, v72.1, v17.1);
                                                                            let v381 = constructor_bxor(ctx, v2.0, v72.0, v380);
                                                                            // Rule at src/opts/cprop.isle line 162.
                                                                            returns.push(v381);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v46 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v47) = v46 {
                                            if v21.0 == v47 {
                                                let v28 = C::inst_data_etor(ctx, v17.0);
                                                let mut v28 = v28;
                                                while let Some(v29) = v28.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v32,
                                                        imm: v33,
                                                    } = &v29.1
                                                    {
                                                        if let &Opcode::Iconst = v32 {
                                                            if v21.0 == v29.0 {
                                                                let v34 =
                                                                    C::u64_from_imm64(ctx, v33);
                                                                let v26 =
                                                                    C::u64_from_imm64(ctx, v25);
                                                                let v309 =
                                                                    C::u64_xor(ctx, v34, v26);
                                                                let v310 =
                                                                    C::imm64_masked(ctx, v47, v309);
                                                                let v311 = constructor_iconst(
                                                                    ctx, v47, v310,
                                                                );
                                                                let v312 = C::subsume(ctx, v311);
                                                                // Rule at src/opts/cprop.isle line 47.
                                                                returns.push(v312);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v138 = C::remat(ctx, arg0);
                                        // Rule at src/opts/algebraic.isle line 314.
                                        returns.push(v138);
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v28 = C::inst_data_etor(ctx, v17.0);
                        let mut v28 = v28;
                        while let Some(v29) = v28.next(ctx) {
                            match &v29.1 {
                                &InstructionData::Unary {
                                    opcode: ref v38,
                                    arg: v39,
                                } => {
                                    if let &Opcode::Bnot = v38 {
                                        if v17.1 == v39 {
                                            let v46 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v47) = v46 {
                                                let v48 = C::ty_int(ctx, v47);
                                                if let Some(v49) = v48 {
                                                    if v29.0 == v49 {
                                                        let v57 = C::ty_mask(ctx, v49);
                                                        let v58 = C::imm64(ctx, v57);
                                                        let v59 = constructor_iconst(ctx, v49, v58);
                                                        let v60 = C::subsume(ctx, v59);
                                                        // Rule at src/opts/algebraic.isle line 143.
                                                        returns.push(v60);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v32,
                                    imm: v33,
                                } => {
                                    if let &Opcode::Iconst = v32 {
                                        if v2.0 == v29.0 {
                                            let v34 = C::u64_from_imm64(ctx, v33);
                                            if v34 == 0x0 {
                                                let v35 = C::subsume(ctx, v17.1);
                                                // Rule at src/opts/algebraic.isle line 130.
                                                returns.push(v35);
                                            }
                                            let v349 = constructor_bxor(ctx, v2.0, v17.1, v17.0);
                                            // Rule at src/opts/cprop.isle line 109.
                                            returns.push(v349);
                                        }
                                        let v138 = C::remat(ctx, arg0);
                                        // Rule at src/opts/algebraic.isle line 312.
                                        returns.push(v138);
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v17.0 == v17.1 {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v51 = C::imm64(ctx, 0x0);
                                    let v52 = constructor_iconst(ctx, v49, v51);
                                    let v53 = C::subsume(ctx, v52);
                                    // Rule at src/opts/algebraic.isle line 136.
                                    returns.push(v53);
                                }
                            }
                        }
                    }
                    &Opcode::Rotl => {
                        let v17 = C::unpack_value_array_2(ctx, v16);
                        let v20 = C::inst_data_etor(ctx, v17.1);
                        let mut v20 = v20;
                        while let Some(v21) = v20.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v24,
                                imm: v25,
                            } = &v21.1
                            {
                                if let &Opcode::Iconst = v24 {
                                    let v26 = C::u64_from_imm64(ctx, v25);
                                    if v26 == 0x0 {
                                        if v2.0 == v21.0 {
                                            let v27 = C::subsume(ctx, v17.0);
                                            // Rule at src/opts/algebraic.isle line 108.
                                            returns.push(v27);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Rotr => {
                        let v17 = C::unpack_value_array_2(ctx, v16);
                        let v20 = C::inst_data_etor(ctx, v17.1);
                        let mut v20 = v20;
                        while let Some(v21) = v20.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v24,
                                imm: v25,
                            } = &v21.1
                            {
                                if let &Opcode::Iconst = v24 {
                                    let v26 = C::u64_from_imm64(ctx, v25);
                                    if v26 == 0x0 {
                                        if v2.0 == v21.0 {
                                            let v27 = C::subsume(ctx, v17.0);
                                            // Rule at src/opts/algebraic.isle line 104.
                                            returns.push(v27);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Ishl => {
                        let v17 = C::unpack_value_array_2(ctx, v16);
                        let v20 = C::inst_data_etor(ctx, v17.1);
                        let mut v20 = v20;
                        while let Some(v21) = v20.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v24,
                                imm: v25,
                            } = &v21.1
                            {
                                if let &Opcode::Iconst = v24 {
                                    let v46 = C::fits_in_64(ctx, v2.0);
                                    if let Some(v47) = v46 {
                                        let v28 = C::inst_data_etor(ctx, v17.0);
                                        let mut v28 = v28;
                                        while let Some(v29) = v28.next(ctx) {
                                            match &v29.1 {
                                                &InstructionData::Binary {
                                                    opcode: ref v70,
                                                    args: ref v71,
                                                } => {
                                                    match v70 {
                                                        &Opcode::Ushr => {
                                                            if v29.0 == v47 {
                                                                let v72 = C::unpack_value_array_2(
                                                                    ctx, v71,
                                                                );
                                                                let v82 =
                                                                    C::inst_data_etor(ctx, v72.1);
                                                                let mut v82 = v82;
                                                                while let Some(v83) = v82.next(ctx)
                                                                {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v86,
                                                                        imm: v87,
                                                                    } = &v83.1 {
                                                                        if let &Opcode::Iconst = v86 {
                                                                            if v25 == v87 {
                                                                                let v111 = C::imm64(ctx, 0xFFFFFFFFFFFFFFFF);
                                                                                let v112 = C::imm64_shl(ctx, v47, v111, v87);
                                                                                let v113 = constructor_iconst(ctx, v47, v112);
                                                                                let v114 = constructor_band(ctx, v47, v72.0, v113);
                                                                                // Rule at src/opts/algebraic.isle line 222.
                                                                                returns.push(v114);
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            if v29.0 == v47 {
                                                                let v72 = C::unpack_value_array_2(
                                                                    ctx, v71,
                                                                );
                                                                let v82 =
                                                                    C::inst_data_etor(ctx, v72.1);
                                                                let mut v82 = v82;
                                                                while let Some(v83) = v82.next(ctx)
                                                                {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v86,
                                                                        imm: v87,
                                                                    } = &v83.1 {
                                                                        if let &Opcode::Iconst = v86 {
                                                                            if v25 == v87 {
                                                                                let v111 = C::imm64(ctx, 0xFFFFFFFFFFFFFFFF);
                                                                                let v112 = C::imm64_shl(ctx, v47, v111, v87);
                                                                                let v113 = constructor_iconst(ctx, v47, v112);
                                                                                let v114 = constructor_band(ctx, v47, v72.0, v113);
                                                                                // Rule at src/opts/algebraic.isle line 227.
                                                                                returns.push(v114);
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v32,
                                                    imm: v33,
                                                } => {
                                                    if let &Opcode::Iconst = v32 {
                                                        if v29.0 == v47 {
                                                            let v320 =
                                                                C::imm64_shl(ctx, v47, v33, v25);
                                                            let v321 =
                                                                constructor_iconst(ctx, v47, v320);
                                                            let v322 = C::subsume(ctx, v321);
                                                            // Rule at src/opts/cprop.isle line 58.
                                                            returns.push(v322);
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    let v26 = C::u64_from_imm64(ctx, v25);
                                    if v26 == 0x0 {
                                        if v2.0 == v21.0 {
                                            let v27 = C::subsume(ctx, v17.0);
                                            // Rule at src/opts/algebraic.isle line 92.
                                            returns.push(v27);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Ushr => {
                        let v17 = C::unpack_value_array_2(ctx, v16);
                        let v20 = C::inst_data_etor(ctx, v17.1);
                        let mut v20 = v20;
                        while let Some(v21) = v20.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v24,
                                imm: v25,
                            } = &v21.1
                            {
                                if let &Opcode::Iconst = v24 {
                                    let v46 = C::fits_in_64(ctx, v2.0);
                                    if let Some(v47) = v46 {
                                        let v28 = C::inst_data_etor(ctx, v17.0);
                                        let mut v28 = v28;
                                        while let Some(v29) = v28.next(ctx) {
                                            match &v29.1 {
                                                &InstructionData::Binary {
                                                    opcode: ref v70,
                                                    args: ref v71,
                                                } => {
                                                    if let &Opcode::Ishl = v70 {
                                                        let v48 = C::ty_int(ctx, v47);
                                                        if let Some(v49) = v48 {
                                                            if v29.0 == v49 {
                                                                let v72 = C::unpack_value_array_2(
                                                                    ctx, v71,
                                                                );
                                                                let v82 =
                                                                    C::inst_data_etor(ctx, v72.1);
                                                                let mut v82 = v82;
                                                                while let Some(v83) = v82.next(ctx)
                                                                {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v86,
                                                                        imm: v87,
                                                                    } = &v83.1 {
                                                                        if let &Opcode::Iconst = v86 {
                                                                            if v25 == v87 {
                                                                                let v57 = C::ty_mask(ctx, v49);
                                                                                let v58 = C::imm64(ctx, v57);
                                                                                let v115 = C::imm64_ushr(ctx, v49, v58, v87);
                                                                                let v116 = constructor_iconst(ctx, v49, v115);
                                                                                let v117 = constructor_band(ctx, v49, v72.0, v116);
                                                                                // Rule at src/opts/algebraic.isle line 237.
                                                                                returns.push(v117);
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v32,
                                                    imm: v33,
                                                } => {
                                                    if let &Opcode::Iconst = v32 {
                                                        if v29.0 == v47 {
                                                            let v323 =
                                                                C::imm64_ushr(ctx, v47, v33, v25);
                                                            let v324 =
                                                                constructor_iconst(ctx, v47, v323);
                                                            let v325 = C::subsume(ctx, v324);
                                                            // Rule at src/opts/cprop.isle line 63.
                                                            returns.push(v325);
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    let v26 = C::u64_from_imm64(ctx, v25);
                                    if v26 == 0x0 {
                                        if v2.0 == v21.0 {
                                            let v27 = C::subsume(ctx, v17.0);
                                            // Rule at src/opts/algebraic.isle line 96.
                                            returns.push(v27);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Sshr => {
                        let v17 = C::unpack_value_array_2(ctx, v16);
                        let v20 = C::inst_data_etor(ctx, v17.1);
                        let mut v20 = v20;
                        while let Some(v21) = v20.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v24,
                                imm: v25,
                            } = &v21.1
                            {
                                if let &Opcode::Iconst = v24 {
                                    let v28 = C::inst_data_etor(ctx, v17.0);
                                    let mut v28 = v28;
                                    while let Some(v29) = v28.next(ctx) {
                                        match &v29.1 {
                                            &InstructionData::Binary {
                                                opcode: ref v70,
                                                args: ref v71,
                                            } => {
                                                if let &Opcode::Ishl = v70 {
                                                    if v2.0 == v29.0 {
                                                        let v72 = C::unpack_value_array_2(ctx, v71);
                                                        let v82 = C::inst_data_etor(ctx, v72.1);
                                                        let mut v82 = v82;
                                                        while let Some(v83) = v82.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v86,
                                                                imm: v87,
                                                            } = &v83.1
                                                            {
                                                                if let &Opcode::Iconst = v86 {
                                                                    if v25 == v87 {
                                                                        let v118 =
                                                                            C::inst_data_etor(
                                                                                ctx, v72.0,
                                                                            );
                                                                        let mut v118 = v118;
                                                                        while let Some(v119) =
                                                                            v118.next(ctx)
                                                                        {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v122,
                                                                                arg: v123,
                                                                            } = &v119.1 {
                                                                                match v122 {
                                                                                    &Opcode::Uextend => {
                                                                                        if v2.0 == v119.0 {
                                                                                            let v88 = C::u64_from_imm64(ctx, v87);
                                                                                            let v125 = C::ty_bits_u64(ctx, v2.0);
                                                                                            let v124 = C::value_type(ctx, v123);
                                                                                            let v126 = C::ty_bits_u64(ctx, v124);
                                                                                            let v127 = C::u64_sub(ctx, v125, v126);
                                                                                            let v128 = C::u64_eq(ctx, v88, v127);
                                                                                            if v128 == true {
                                                                                                let v129 = constructor_sextend(ctx, v2.0, v123);
                                                                                                // Rule at src/opts/algebraic.isle line 247.
                                                                                                returns.push(v129);
                                                                                            }
                                                                                            let v130 = C::u64_lt(ctx, v88, v127);
                                                                                            if v130 == true {
                                                                                                // Rule at src/opts/algebraic.isle line 259.
                                                                                                returns.push(v72.0);
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    &Opcode::Sextend => {
                                                                                        let v88 = C::u64_from_imm64(ctx, v87);
                                                                                        let v125 = C::ty_bits_u64(ctx, v2.0);
                                                                                        let v124 = C::value_type(ctx, v123);
                                                                                        let v126 = C::ty_bits_u64(ctx, v124);
                                                                                        let v127 = C::u64_sub(ctx, v125, v126);
                                                                                        let v131 = C::u64_le(ctx, v88, v127);
                                                                                        if v131 == true {
                                                                                            if v2.0 == v119.0 {
                                                                                                // Rule at src/opts/algebraic.isle line 270.
                                                                                                returns.push(v72.0);
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                    _ => {}
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &InstructionData::UnaryImm {
                                                opcode: ref v32,
                                                imm: v33,
                                            } => {
                                                if let &Opcode::Iconst = v32 {
                                                    let v46 = C::fits_in_64(ctx, v2.0);
                                                    if let Some(v47) = v46 {
                                                        if v29.0 == v47 {
                                                            let v326 =
                                                                C::imm64_sshr(ctx, v47, v33, v25);
                                                            let v327 =
                                                                constructor_iconst(ctx, v47, v326);
                                                            let v328 = C::subsume(ctx, v327);
                                                            // Rule at src/opts/cprop.isle line 68.
                                                            returns.push(v328);
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    let v26 = C::u64_from_imm64(ctx, v25);
                                    if v26 == 0x0 {
                                        if v2.0 == v21.0 {
                                            let v27 = C::subsume(ctx, v17.0);
                                            // Rule at src/opts/algebraic.isle line 100.
                                            returns.push(v27);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Fmul => {
                        let v17 = C::unpack_value_array_2(ctx, v16);
                        let v20 = C::inst_data_etor(ctx, v17.1);
                        let mut v20 = v20;
                        while let Some(v21) = v20.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v40,
                                arg: v41,
                            } = &v21.1
                            {
                                if let &Opcode::Fneg = v40 {
                                    if v2.0 == v21.0 {
                                        let v28 = C::inst_data_etor(ctx, v17.0);
                                        let mut v28 = v28;
                                        while let Some(v29) = v28.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v38,
                                                arg: v39,
                                            } = &v29.1
                                            {
                                                if let &Opcode::Fneg = v38 {
                                                    if v2.0 == v29.0 {
                                                        let v211 =
                                                            constructor_fmul(ctx, v2.0, v39, v41);
                                                        // Rule at src/opts/algebraic.isle line 410.
                                                        returns.push(v211);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v146,
                args: ref v147,
                cond: ref v148,
            } => {
                if let &Opcode::Icmp = v146 {
                    match v148 {
                        &IntCC::Equal => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    if v149.0 == v149.1 {
                                        let v168 = C::imm64(ctx, 0x1);
                                        let v212 = constructor_iconst(ctx, v49, v168);
                                        // Rule at src/opts/icmp.isle line 5.
                                        returns.push(v212);
                                    }
                                }
                            }
                            let v149 = C::unpack_value_array_2(ctx, v147);
                            let v152 = C::inst_data_etor(ctx, v149.0);
                            let mut v152 = v152;
                            while let Some(v153) = v152.next(ctx) {
                                if let &InstructionData::Unary {
                                    opcode: ref v156,
                                    arg: v157,
                                } = &v153.1
                                {
                                    if let &Opcode::Uextend = v156 {
                                        let v159 = C::inst_data_etor(ctx, v149.1);
                                        let mut v159 = v159;
                                        while let Some(v160) = v159.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v163,
                                                imm: v164,
                                            } = &v160.1
                                            {
                                                if let &Opcode::Iconst = v163 {
                                                    let v165 = C::u64_from_imm64(ctx, v164);
                                                    if v165 == 0x0 {
                                                        let v213 = C::inst_data_etor(ctx, v157);
                                                        let mut v213 = v213;
                                                        while let Some(v214) = v213.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v217,
                                                                args: ref v218,
                                                                cond: ref v219,
                                                            } = &v214.1
                                                            {
                                                                if let &Opcode::Icmp = v217 {
                                                                    if v2.0 == v214.0 {
                                                                        let v224 =
                                                                            &C::intcc_inverse(
                                                                                ctx, v219,
                                                                            );
                                                                        let v220 =
                                                                            C::unpack_value_array_2(
                                                                                ctx, v218,
                                                                            );
                                                                        let v225 = constructor_icmp(
                                                                            ctx, v2.0, v224,
                                                                            v220.0, v220.1,
                                                                        );
                                                                        let v226 =
                                                                            C::subsume(ctx, v225);
                                                                        // Rule at src/opts/icmp.isle line 22.
                                                                        returns.push(v226);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        &IntCC::NotEqual => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    if v149.0 == v149.1 {
                                        let v51 = C::imm64(ctx, 0x0);
                                        let v52 = constructor_iconst(ctx, v49, v51);
                                        // Rule at src/opts/icmp.isle line 6.
                                        returns.push(v52);
                                    }
                                }
                            }
                            let v149 = C::unpack_value_array_2(ctx, v147);
                            let v152 = C::inst_data_etor(ctx, v149.0);
                            let mut v152 = v152;
                            while let Some(v153) = v152.next(ctx) {
                                if let &InstructionData::Unary {
                                    opcode: ref v156,
                                    arg: v157,
                                } = &v153.1
                                {
                                    if let &Opcode::Uextend = v156 {
                                        let v159 = C::inst_data_etor(ctx, v149.1);
                                        let mut v159 = v159;
                                        while let Some(v160) = v159.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v163,
                                                imm: v164,
                                            } = &v160.1
                                            {
                                                if let &Opcode::Iconst = v163 {
                                                    let v165 = C::u64_from_imm64(ctx, v164);
                                                    if v165 == 0x0 {
                                                        let v213 = C::inst_data_etor(ctx, v157);
                                                        let mut v213 = v213;
                                                        while let Some(v214) = v213.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v217,
                                                                args: ref v218,
                                                                cond: ref v219,
                                                            } = &v214.1
                                                            {
                                                                if let &Opcode::Icmp = v217 {
                                                                    if v2.0 == v214.0 {
                                                                        let v223 =
                                                                            C::subsume(ctx, v157);
                                                                        // Rule at src/opts/icmp.isle line 17.
                                                                        returns.push(v223);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThan => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    let v159 = C::inst_data_etor(ctx, v149.1);
                                    let mut v159 = v159;
                                    while let Some(v160) = v159.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v163,
                                            imm: v164,
                                        } = &v160.1
                                        {
                                            if let &Opcode::Iconst = v163 {
                                                let v165 = C::u64_from_imm64(ctx, v164);
                                                let v261 = C::ty_smin(ctx, v160.0);
                                                let v262 = C::u64_eq(ctx, v165, v261);
                                                if v262 == true {
                                                    let v257 =
                                                        constructor_ne(ctx, v49, v149.0, v149.1);
                                                    // Rule at src/opts/icmp.isle line 98.
                                                    returns.push(v257);
                                                }
                                                let v263 = C::ty_smax(ctx, v160.0);
                                                let v264 = C::u64_eq(ctx, v165, v263);
                                                if v264 == true {
                                                    let v51 = C::imm64(ctx, 0x0);
                                                    let v52 = constructor_iconst(ctx, v49, v51);
                                                    let v53 = C::subsume(ctx, v52);
                                                    // Rule at src/opts/icmp.isle line 118.
                                                    returns.push(v53);
                                                }
                                            }
                                        }
                                    }
                                    if v149.0 == v149.1 {
                                        let v51 = C::imm64(ctx, 0x0);
                                        let v52 = constructor_iconst(ctx, v49, v51);
                                        // Rule at src/opts/icmp.isle line 9.
                                        returns.push(v52);
                                    }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThanOrEqual => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    let v159 = C::inst_data_etor(ctx, v149.1);
                                    let mut v159 = v159;
                                    while let Some(v160) = v159.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v163,
                                            imm: v164,
                                        } = &v160.1
                                        {
                                            if let &Opcode::Iconst = v163 {
                                                let v165 = C::u64_from_imm64(ctx, v164);
                                                let v261 = C::ty_smin(ctx, v160.0);
                                                let v262 = C::u64_eq(ctx, v165, v261);
                                                if v262 == true {
                                                    let v168 = C::imm64(ctx, 0x1);
                                                    let v212 = constructor_iconst(ctx, v49, v168);
                                                    let v258 = C::subsume(ctx, v212);
                                                    // Rule at src/opts/icmp.isle line 103.
                                                    returns.push(v258);
                                                }
                                                let v263 = C::ty_smax(ctx, v160.0);
                                                let v264 = C::u64_eq(ctx, v165, v263);
                                                if v264 == true {
                                                    let v256 =
                                                        constructor_eq(ctx, v49, v149.0, v149.1);
                                                    // Rule at src/opts/icmp.isle line 123.
                                                    returns.push(v256);
                                                }
                                            }
                                        }
                                    }
                                    if v149.0 == v149.1 {
                                        let v168 = C::imm64(ctx, 0x1);
                                        let v212 = constructor_iconst(ctx, v49, v168);
                                        // Rule at src/opts/icmp.isle line 10.
                                        returns.push(v212);
                                    }
                                }
                            }
                            let v149 = C::unpack_value_array_2(ctx, v147);
                            let v152 = C::inst_data_etor(ctx, v149.0);
                            let mut v152 = v152;
                            while let Some(v153) = v152.next(ctx) {
                                if v153.0 == I64 {
                                    if let &InstructionData::Unary {
                                        opcode: ref v156,
                                        arg: v157,
                                    } = &v153.1
                                    {
                                        if let &Opcode::Uextend = v156 {
                                            let v158 = C::value_type(ctx, v157);
                                            if v158 == I32 {
                                                let v159 = C::inst_data_etor(ctx, v149.1);
                                                let mut v159 = v159;
                                                while let Some(v160) = v159.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v163,
                                                        imm: v164,
                                                    } = &v160.1
                                                    {
                                                        if let &Opcode::Iconst = v163 {
                                                            let v165 = C::u64_from_imm64(ctx, v164);
                                                            if v165 == 0x0 {
                                                                let v168 = C::imm64(ctx, 0x1);
                                                                let v169 = constructor_iconst(
                                                                    ctx, v2.0, v168,
                                                                );
                                                                // Rule at src/opts/algebraic.isle line 336.
                                                                returns.push(v169);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        &IntCC::SignedLessThan => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    let v159 = C::inst_data_etor(ctx, v149.1);
                                    let mut v159 = v159;
                                    while let Some(v160) = v159.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v163,
                                            imm: v164,
                                        } = &v160.1
                                        {
                                            if let &Opcode::Iconst = v163 {
                                                let v165 = C::u64_from_imm64(ctx, v164);
                                                let v261 = C::ty_smin(ctx, v160.0);
                                                let v262 = C::u64_eq(ctx, v165, v261);
                                                if v262 == true {
                                                    let v51 = C::imm64(ctx, 0x0);
                                                    let v52 = constructor_iconst(ctx, v49, v51);
                                                    let v53 = C::subsume(ctx, v52);
                                                    // Rule at src/opts/icmp.isle line 88.
                                                    returns.push(v53);
                                                }
                                                let v263 = C::ty_smax(ctx, v160.0);
                                                let v264 = C::u64_eq(ctx, v165, v263);
                                                if v264 == true {
                                                    let v257 =
                                                        constructor_ne(ctx, v49, v149.0, v149.1);
                                                    // Rule at src/opts/icmp.isle line 108.
                                                    returns.push(v257);
                                                }
                                            }
                                        }
                                    }
                                    if v149.0 == v149.1 {
                                        let v51 = C::imm64(ctx, 0x0);
                                        let v52 = constructor_iconst(ctx, v49, v51);
                                        // Rule at src/opts/icmp.isle line 13.
                                        returns.push(v52);
                                    }
                                }
                            }
                            let v149 = C::unpack_value_array_2(ctx, v147);
                            let v152 = C::inst_data_etor(ctx, v149.0);
                            let mut v152 = v152;
                            while let Some(v153) = v152.next(ctx) {
                                if v153.0 == I64 {
                                    if let &InstructionData::Unary {
                                        opcode: ref v156,
                                        arg: v157,
                                    } = &v153.1
                                    {
                                        if let &Opcode::Uextend = v156 {
                                            let v158 = C::value_type(ctx, v157);
                                            if v158 == I32 {
                                                let v159 = C::inst_data_etor(ctx, v149.1);
                                                let mut v159 = v159;
                                                while let Some(v160) = v159.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v163,
                                                        imm: v164,
                                                    } = &v160.1
                                                    {
                                                        if let &Opcode::Iconst = v163 {
                                                            let v165 = C::u64_from_imm64(ctx, v164);
                                                            if v165 == 0x0 {
                                                                let v51 = C::imm64(ctx, 0x0);
                                                                let v166 = constructor_iconst(
                                                                    ctx, v2.0, v51,
                                                                );
                                                                // Rule at src/opts/algebraic.isle line 331.
                                                                returns.push(v166);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        &IntCC::SignedLessThanOrEqual => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    let v159 = C::inst_data_etor(ctx, v149.1);
                                    let mut v159 = v159;
                                    while let Some(v160) = v159.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v163,
                                            imm: v164,
                                        } = &v160.1
                                        {
                                            if let &Opcode::Iconst = v163 {
                                                let v165 = C::u64_from_imm64(ctx, v164);
                                                let v261 = C::ty_smin(ctx, v160.0);
                                                let v262 = C::u64_eq(ctx, v165, v261);
                                                if v262 == true {
                                                    let v256 =
                                                        constructor_eq(ctx, v49, v149.0, v149.1);
                                                    // Rule at src/opts/icmp.isle line 93.
                                                    returns.push(v256);
                                                }
                                                let v263 = C::ty_smax(ctx, v160.0);
                                                let v264 = C::u64_eq(ctx, v165, v263);
                                                if v264 == true {
                                                    let v168 = C::imm64(ctx, 0x1);
                                                    let v212 = constructor_iconst(ctx, v49, v168);
                                                    let v258 = C::subsume(ctx, v212);
                                                    // Rule at src/opts/icmp.isle line 113.
                                                    returns.push(v258);
                                                }
                                            }
                                        }
                                    }
                                    if v149.0 == v149.1 {
                                        let v168 = C::imm64(ctx, 0x1);
                                        let v212 = constructor_iconst(ctx, v49, v168);
                                        // Rule at src/opts/icmp.isle line 14.
                                        returns.push(v212);
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThan => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    let v159 = C::inst_data_etor(ctx, v149.1);
                                    let mut v159 = v159;
                                    while let Some(v160) = v159.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v163,
                                            imm: v164,
                                        } = &v160.1
                                        {
                                            if let &Opcode::Iconst = v163 {
                                                let v165 = C::u64_from_imm64(ctx, v164);
                                                if v165 == 0x0 {
                                                    let v257 =
                                                        constructor_ne(ctx, v49, v149.0, v149.1);
                                                    // Rule at src/opts/icmp.isle line 60.
                                                    returns.push(v257);
                                                }
                                                let v259 = C::ty_umax(ctx, v160.0);
                                                let v260 = C::u64_eq(ctx, v165, v259);
                                                if v260 == true {
                                                    let v51 = C::imm64(ctx, 0x0);
                                                    let v52 = constructor_iconst(ctx, v49, v51);
                                                    let v53 = C::subsume(ctx, v52);
                                                    // Rule at src/opts/icmp.isle line 78.
                                                    returns.push(v53);
                                                }
                                            }
                                        }
                                    }
                                    if v149.0 == v149.1 {
                                        let v51 = C::imm64(ctx, 0x0);
                                        let v52 = constructor_iconst(ctx, v49, v51);
                                        // Rule at src/opts/icmp.isle line 7.
                                        returns.push(v52);
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThanOrEqual => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    let v159 = C::inst_data_etor(ctx, v149.1);
                                    let mut v159 = v159;
                                    while let Some(v160) = v159.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v163,
                                            imm: v164,
                                        } = &v160.1
                                        {
                                            if let &Opcode::Iconst = v163 {
                                                let v165 = C::u64_from_imm64(ctx, v164);
                                                if v165 == 0x0 {
                                                    let v168 = C::imm64(ctx, 0x1);
                                                    let v212 = constructor_iconst(ctx, v49, v168);
                                                    let v258 = C::subsume(ctx, v212);
                                                    // Rule at src/opts/icmp.isle line 64.
                                                    returns.push(v258);
                                                }
                                                let v259 = C::ty_umax(ctx, v160.0);
                                                let v260 = C::u64_eq(ctx, v165, v259);
                                                if v260 == true {
                                                    let v256 =
                                                        constructor_eq(ctx, v49, v149.0, v149.1);
                                                    // Rule at src/opts/icmp.isle line 83.
                                                    returns.push(v256);
                                                }
                                            }
                                        }
                                    }
                                    if v149.0 == v149.1 {
                                        let v168 = C::imm64(ctx, 0x1);
                                        let v212 = constructor_iconst(ctx, v49, v168);
                                        // Rule at src/opts/icmp.isle line 8.
                                        returns.push(v212);
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThan => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    let v159 = C::inst_data_etor(ctx, v149.1);
                                    let mut v159 = v159;
                                    while let Some(v160) = v159.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v163,
                                            imm: v164,
                                        } = &v160.1
                                        {
                                            if let &Opcode::Iconst = v163 {
                                                let v165 = C::u64_from_imm64(ctx, v164);
                                                if v165 == 0x0 {
                                                    let v51 = C::imm64(ctx, 0x0);
                                                    let v52 = constructor_iconst(ctx, v49, v51);
                                                    let v53 = C::subsume(ctx, v52);
                                                    // Rule at src/opts/icmp.isle line 52.
                                                    returns.push(v53);
                                                }
                                                let v259 = C::ty_umax(ctx, v160.0);
                                                let v260 = C::u64_eq(ctx, v165, v259);
                                                if v260 == true {
                                                    let v257 =
                                                        constructor_ne(ctx, v49, v149.0, v149.1);
                                                    // Rule at src/opts/icmp.isle line 68.
                                                    returns.push(v257);
                                                }
                                            }
                                        }
                                    }
                                    if v149.0 == v149.1 {
                                        let v51 = C::imm64(ctx, 0x0);
                                        let v52 = constructor_iconst(ctx, v49, v51);
                                        // Rule at src/opts/icmp.isle line 11.
                                        returns.push(v52);
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThanOrEqual => {
                            let v46 = C::fits_in_64(ctx, v2.0);
                            if let Some(v47) = v46 {
                                let v48 = C::ty_int(ctx, v47);
                                if let Some(v49) = v48 {
                                    let v149 = C::unpack_value_array_2(ctx, v147);
                                    let v159 = C::inst_data_etor(ctx, v149.1);
                                    let mut v159 = v159;
                                    while let Some(v160) = v159.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v163,
                                            imm: v164,
                                        } = &v160.1
                                        {
                                            if let &Opcode::Iconst = v163 {
                                                let v165 = C::u64_from_imm64(ctx, v164);
                                                if v165 == 0x0 {
                                                    let v256 =
                                                        constructor_eq(ctx, v49, v149.0, v149.1);
                                                    // Rule at src/opts/icmp.isle line 56.
                                                    returns.push(v256);
                                                }
                                                let v259 = C::ty_umax(ctx, v160.0);
                                                let v260 = C::u64_eq(ctx, v165, v259);
                                                if v260 == true {
                                                    let v168 = C::imm64(ctx, 0x1);
                                                    let v212 = constructor_iconst(ctx, v49, v168);
                                                    let v258 = C::subsume(ctx, v212);
                                                    // Rule at src/opts/icmp.isle line 73.
                                                    returns.push(v258);
                                                }
                                            }
                                        }
                                    }
                                    if v149.0 == v149.1 {
                                        let v168 = C::imm64(ctx, 0x1);
                                        let v212 = constructor_iconst(ctx, v49, v168);
                                        // Rule at src/opts/icmp.isle line 12.
                                        returns.push(v212);
                                    }
                                }
                            }
                        }
                        _ => {}
                    }
                    let v149 = C::unpack_value_array_2(ctx, v147);
                    let v152 = C::inst_data_etor(ctx, v149.0);
                    let mut v152 = v152;
                    while let Some(v153) = v152.next(ctx) {
                        if let &InstructionData::UnaryImm {
                            opcode: ref v338,
                            imm: v339,
                        } = &v153.1
                        {
                            if let &Opcode::Iconst = v338 {
                                let v159 = C::inst_data_etor(ctx, v149.1);
                                let mut v159 = v159;
                                while let Some(v160) = v159.next(ctx) {
                                    if let &InstructionData::UnaryImm {
                                        opcode: ref v163,
                                        imm: v164,
                                    } = &v160.1
                                    {
                                        if let &Opcode::Iconst = v163 {
                                            if v153.0 == v160.0 {
                                                let v340 =
                                                    C::imm64_icmp(ctx, v153.0, v148, v339, v164);
                                                let v341 = constructor_iconst(ctx, v2.0, v340);
                                                let v342 = C::subsume(ctx, v341);
                                                // Rule at src/opts/cprop.isle line 79.
                                                returns.push(v342);
                                            }
                                        }
                                    }
                                }
                                let v350 = &C::intcc_reverse(ctx, v148);
                                let v351 = constructor_icmp(ctx, v2.0, v350, v149.1, v149.0);
                                // Rule at src/opts/cprop.isle line 113.
                                returns.push(v351);
                            }
                        }
                    }
                }
            }
            &InstructionData::Ternary {
                opcode: ref v170,
                args: ref v171,
            } => {
                match v170 {
                    &Opcode::Select => {
                        let v172 = C::unpack_value_array_3(ctx, v171);
                        let v176 = C::inst_data_etor(ctx, v172.0);
                        let mut v176 = v176;
                        while let Some(v177) = v176.next(ctx) {
                            match &v177.1 {
                                &InstructionData::FloatCompare {
                                    opcode: ref v194,
                                    args: ref v195,
                                    cond: ref v196,
                                } => {
                                    if let &Opcode::Fcmp = v194 {
                                        match v196 {
                                            &FloatCC::GreaterThan => {
                                                let v197 = C::unpack_value_array_2(ctx, v195);
                                                if v172.1 == v197.0 {
                                                    if v172.2 == v197.1 {
                                                        let v201 = constructor_fmax_pseudo(
                                                            ctx, v2.0, v197.0, v197.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 392.
                                                        returns.push(v201);
                                                    }
                                                }
                                            }
                                            &FloatCC::LessThan => {
                                                let v197 = C::unpack_value_array_2(ctx, v195);
                                                if v172.1 == v197.0 {
                                                    if v172.2 == v197.1 {
                                                        let v200 = constructor_fmin_pseudo(
                                                            ctx, v2.0, v197.0, v197.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 389.
                                                        returns.push(v200);
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v180,
                                    args: ref v181,
                                    cond: ref v182,
                                } => {
                                    if let &Opcode::Icmp = v180 {
                                        match v182 {
                                            &IntCC::SignedGreaterThan => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v186 = constructor_smax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 343.
                                                        returns.push(v186);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v188 = constructor_smin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 357.
                                                        returns.push(v188);
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v186 = constructor_smax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 344.
                                                        returns.push(v186);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v188 = constructor_smin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 358.
                                                        returns.push(v188);
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v188 = constructor_smin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 347.
                                                        returns.push(v188);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v186 = constructor_smax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 353.
                                                        returns.push(v186);
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v188 = constructor_smin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 348.
                                                        returns.push(v188);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v186 = constructor_smax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 354.
                                                        returns.push(v186);
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v187 = constructor_umax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 345.
                                                        returns.push(v187);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v189 = constructor_umin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 359.
                                                        returns.push(v189);
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v187 = constructor_umax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 346.
                                                        returns.push(v187);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v189 = constructor_umin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 360.
                                                        returns.push(v189);
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v189 = constructor_umin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 349.
                                                        returns.push(v189);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v187 = constructor_umax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 355.
                                                        returns.push(v187);
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v189 = constructor_umin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 350.
                                                        returns.push(v189);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v187 = constructor_umax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 356.
                                                        returns.push(v187);
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v202,
                                    arg: v203,
                                } => {
                                    if let &Opcode::Uextend = v202 {
                                        let v227 = C::inst_data_etor(ctx, v203);
                                        let mut v227 = v227;
                                        while let Some(v228) = v227.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v231,
                                                args: ref v232,
                                                cond: ref v233,
                                            } = &v228.1
                                            {
                                                if let &Opcode::Icmp = v231 {
                                                    let v237 = constructor_select(
                                                        ctx, v2.0, v203, v172.1, v172.2,
                                                    );
                                                    // Rule at src/opts/icmp.isle line 29.
                                                    returns.push(v237);
                                                    // Rule at src/opts/icmp.isle line 32.
                                                    returns.push(v237);
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v382,
                                    imm: v383,
                                } => {
                                    if let &Opcode::Iconst = v382 {
                                        let v384 = C::u64_from_imm64(ctx, v383);
                                        if v384 == 0x0 {
                                            // Rule at src/opts/cprop.isle line 169.
                                            returns.push(v172.2);
                                        }
                                        let v385 = C::u64_is_zero(ctx, v384);
                                        if v385 == false {
                                            // Rule at src/opts/cprop.isle line 166.
                                            returns.push(v172.1);
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Bitselect => {
                        let v190 = C::multi_lane(ctx, v2.0);
                        if let Some(v191) = v190 {
                            let v172 = C::unpack_value_array_3(ctx, v171);
                            let v176 = C::inst_data_etor(ctx, v172.0);
                            let mut v176 = v176;
                            while let Some(v177) = v176.next(ctx) {
                                if let &InstructionData::IntCompare {
                                    opcode: ref v180,
                                    args: ref v181,
                                    cond: ref v182,
                                } = &v177.1
                                {
                                    if let &Opcode::Icmp = v180 {
                                        match v182 {
                                            &IntCC::SignedGreaterThan => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v186 = constructor_smax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 363.
                                                        returns.push(v186);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v188 = constructor_smin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 377.
                                                        returns.push(v188);
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v186 = constructor_smax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 364.
                                                        returns.push(v186);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v188 = constructor_smin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 378.
                                                        returns.push(v188);
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v188 = constructor_smin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 367.
                                                        returns.push(v188);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v186 = constructor_smax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 373.
                                                        returns.push(v186);
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v188 = constructor_smin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 368.
                                                        returns.push(v188);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v186 = constructor_smax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 374.
                                                        returns.push(v186);
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v187 = constructor_umax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 365.
                                                        returns.push(v187);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v189 = constructor_umin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 379.
                                                        returns.push(v189);
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v187 = constructor_umax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 366.
                                                        returns.push(v187);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v189 = constructor_umin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 380.
                                                        returns.push(v189);
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v189 = constructor_umin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 369.
                                                        returns.push(v189);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v187 = constructor_umax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 375.
                                                        returns.push(v187);
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v183 = C::unpack_value_array_2(ctx, v181);
                                                if v172.1 == v183.0 {
                                                    if v172.2 == v183.1 {
                                                        let v189 = constructor_umin(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 370.
                                                        returns.push(v189);
                                                    }
                                                }
                                                if v172.1 == v183.1 {
                                                    if v172.2 == v183.0 {
                                                        let v187 = constructor_umax(
                                                            ctx, v2.0, v183.0, v183.1,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 376.
                                                        returns.push(v187);
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Fma => {
                        let v172 = C::unpack_value_array_3(ctx, v171);
                        let v176 = C::inst_data_etor(ctx, v172.0);
                        let mut v176 = v176;
                        while let Some(v177) = v176.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v202,
                                arg: v203,
                            } = &v177.1
                            {
                                if let &Opcode::Fneg = v202 {
                                    if v2.0 == v177.0 {
                                        let v204 = C::inst_data_etor(ctx, v172.1);
                                        let mut v204 = v204;
                                        while let Some(v205) = v204.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v208,
                                                arg: v209,
                                            } = &v205.1
                                            {
                                                if let &Opcode::Fneg = v208 {
                                                    if v2.0 == v205.0 {
                                                        let v210 = constructor_fma(
                                                            ctx, v2.0, v203, v209, v172.2,
                                                        );
                                                        // Rule at src/opts/algebraic.isle line 405.
                                                        returns.push(v210);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::Unary {
                opcode: ref v5,
                arg: v6,
            } => {
                match v5 {
                    &Opcode::Ineg => {
                        let v7 = C::inst_data_etor(ctx, v6);
                        let mut v7 = v7;
                        while let Some(v8) = v7.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v11,
                                arg: v12,
                            } = &v8.1
                            {
                                if let &Opcode::Ineg = v11 {
                                    if v2.0 == v8.0 {
                                        let v37 = C::subsume(ctx, v12);
                                        // Rule at src/opts/algebraic.isle line 36.
                                        returns.push(v37);
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Iabs => {
                        let v7 = C::inst_data_etor(ctx, v6);
                        let mut v7 = v7;
                        while let Some(v8) = v7.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v11,
                                arg: v12,
                            } = &v8.1
                            {
                                match v11 {
                                    &Opcode::Ineg => {
                                        if v2.0 == v8.0 {
                                            let v44 = constructor_iabs(ctx, v2.0, v12);
                                            // Rule at src/opts/algebraic.isle line 43.
                                            returns.push(v44);
                                        }
                                    }
                                    &Opcode::Iabs => {
                                        if v2.0 == v8.0 {
                                            let v45 = C::subsume(ctx, v6);
                                            // Rule at src/opts/algebraic.isle line 47.
                                            returns.push(v45);
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    &Opcode::Bnot => {
                        let v7 = C::inst_data_etor(ctx, v6);
                        let mut v7 = v7;
                        while let Some(v8) = v7.next(ctx) {
                            match &v8.1 {
                                &InstructionData::Binary {
                                    opcode: ref v61,
                                    args: ref v62,
                                } => {
                                    match v61 {
                                        &Opcode::Band => {
                                            let v63 = C::unpack_value_array_2(ctx, v62);
                                            let v66 = constructor_bnot(ctx, v2.0, v63.0);
                                            let v67 = constructor_bnot(ctx, v2.0, v63.1);
                                            let v69 = constructor_bor(ctx, v2.0, v66, v67);
                                            // Rule at src/opts/algebraic.isle line 170.
                                            returns.push(v69);
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v8.0 {
                                                let v63 = C::unpack_value_array_2(ctx, v62);
                                                let v66 = constructor_bnot(ctx, v2.0, v63.0);
                                                let v67 = constructor_bnot(ctx, v2.0, v63.1);
                                                let v68 = constructor_band(ctx, v2.0, v66, v67);
                                                // Rule at src/opts/algebraic.isle line 167.
                                                returns.push(v68);
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v11,
                                    arg: v12,
                                } => {
                                    if let &Opcode::Bnot = v11 {
                                        if v2.0 == v8.0 {
                                            let v37 = C::subsume(ctx, v12);
                                            // Rule at src/opts/algebraic.isle line 163.
                                            returns.push(v37);
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v313,
                                    imm: v314,
                                } => {
                                    if let &Opcode::Iconst = v313 {
                                        let v46 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v47) = v46 {
                                            if v8.0 == v47 {
                                                let v315 = C::u64_from_imm64(ctx, v314);
                                                let v316 = C::u64_not(ctx, v315);
                                                let v317 = C::imm64_masked(ctx, v47, v316);
                                                let v318 = constructor_iconst(ctx, v47, v317);
                                                let v319 = C::subsume(ctx, v318);
                                                // Rule at src/opts/cprop.isle line 53.
                                                returns.push(v319);
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v138 = C::remat(ctx, arg0);
                        // Rule at src/opts/algebraic.isle line 316.
                        returns.push(v138);
                    }
                    &Opcode::Fneg => {
                        let v7 = C::inst_data_etor(ctx, v6);
                        let mut v7 = v7;
                        while let Some(v8) = v7.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v11,
                                arg: v12,
                            } = &v8.1
                            {
                                if let &Opcode::Fneg = v11 {
                                    if v2.0 == v8.0 {
                                        let v37 = C::subsume(ctx, v12);
                                        // Rule at src/opts/algebraic.isle line 401.
                                        returns.push(v37);
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Uextend => {
                        let v7 = C::inst_data_etor(ctx, v6);
                        let mut v7 = v7;
                        while let Some(v8) = v7.next(ctx) {
                            match &v8.1 {
                                &InstructionData::Unary {
                                    opcode: ref v11,
                                    arg: v12,
                                } => {
                                    if let &Opcode::Uextend = v11 {
                                        let v13 = constructor_uextend(ctx, v2.0, v12);
                                        // Rule at src/opts/algebraic.isle line 10.
                                        returns.push(v13);
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v313,
                                    imm: v314,
                                } => {
                                    if let &Opcode::Iconst = v313 {
                                        let v46 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v47) = v46 {
                                            let v329 = C::u64_uextend_imm64(ctx, v8.0, v314);
                                            let v330 = C::imm64(ctx, v329);
                                            let v331 = constructor_iconst(ctx, v47, v330);
                                            let v332 = C::subsume(ctx, v331);
                                            // Rule at src/opts/cprop.isle line 73.
                                            returns.push(v332);
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Sextend => {
                        let v7 = C::inst_data_etor(ctx, v6);
                        let mut v7 = v7;
                        while let Some(v8) = v7.next(ctx) {
                            match &v8.1 {
                                &InstructionData::Unary {
                                    opcode: ref v11,
                                    arg: v12,
                                } => {
                                    if let &Opcode::Sextend = v11 {
                                        let v14 = constructor_sextend(ctx, v2.0, v12);
                                        // Rule at src/opts/algebraic.isle line 12.
                                        returns.push(v14);
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v313,
                                    imm: v314,
                                } => {
                                    if let &Opcode::Iconst = v313 {
                                        let v46 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v47) = v46 {
                                            let v333 = C::i64_sextend_imm64(ctx, v8.0, v314);
                                            let v334 = C::i64_as_u64(ctx, v333);
                                            let v335 = C::imm64_masked(ctx, v47, v334);
                                            let v336 = constructor_iconst(ctx, v47, v335);
                                            let v337 = C::subsume(ctx, v336);
                                            // Rule at src/opts/cprop.isle line 76.
                                            returns.push(v337);
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::UnaryIeee32 {
                opcode: ref v141,
                imm: v142,
            } => {
                if let &Opcode::F32const = v141 {
                    let v138 = C::remat(ctx, arg0);
                    // Rule at src/opts/algebraic.isle line 320.
                    returns.push(v138);
                }
            }
            &InstructionData::UnaryIeee64 {
                opcode: ref v143,
                imm: v144,
            } => {
                if let &Opcode::F64const = v143 {
                    let v138 = C::remat(ctx, arg0);
                    // Rule at src/opts/algebraic.isle line 322.
                    returns.push(v138);
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v139,
                imm: v140,
            } => {
                if let &Opcode::Iconst = v139 {
                    let v138 = C::remat(ctx, arg0);
                    // Rule at src/opts/algebraic.isle line 318.
                    returns.push(v138);
                }
            }
            _ => {}
        }
    }
    return ContextIterWrapper::from(returns.into_iter());
}
// Generated as internal constructor for term intcc_comparable.
pub fn constructor_intcc_comparable<C: Context>(
    ctx: &mut C,
    arg0: &IntCC,
    arg1: &IntCC,
) -> Option<bool> {
    let v2 = constructor_intcc_class(ctx, arg0);
    let v3 = constructor_intcc_class(ctx, arg1);
    let v4 = C::u64_and(ctx, v2, v3);
    let v5 = C::u64_is_zero(ctx, v4);
    if v5 == false {
        let v7 = C::u64_eq(ctx, 0x2, v4);
        // Rule at src/opts/icmp.isle line 137.
        return Some(v7);
    }
    None
}
// Generated as internal constructor for term decompose_intcc.
pub fn constructor_decompose_intcc<C: Context>(ctx: &mut C, arg0: &IntCC) -> u64 {
    match arg0 {
        &IntCC::Equal => {
            // Rule at src/opts/icmp.isle line 142.
            return 0x1;
        }
        &IntCC::NotEqual => {
            // Rule at src/opts/icmp.isle line 151.
            return 0x6;
        }
        &IntCC::SignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 148.
            return 0x4;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 150.
            return 0x5;
        }
        &IntCC::SignedLessThan => {
            // Rule at src/opts/icmp.isle line 144.
            return 0x2;
        }
        &IntCC::SignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 146.
            return 0x3;
        }
        &IntCC::UnsignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 147.
            return 0x4;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 149.
            return 0x5;
        }
        &IntCC::UnsignedLessThan => {
            // Rule at src/opts/icmp.isle line 143.
            return 0x2;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 145.
            return 0x3;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "decompose_intcc", "src/opts/icmp.isle line 141"
    )
}
// Generated as internal constructor for term compose_icmp.
pub fn constructor_compose_icmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: u64,
    arg2: bool,
    arg3: Value,
    arg4: Value,
) -> Value {
    match arg1 {
        0x0 => {
            let v6 = C::imm64(ctx, 0x0);
            let v7 = constructor_iconst(ctx, arg0, v6);
            let v8 = C::subsume(ctx, v7);
            // Rule at src/opts/icmp.isle line 154.
            return v8;
        }
        0x1 => {
            let v10 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg3, arg4);
            // Rule at src/opts/icmp.isle line 155.
            return v10;
        }
        0x2 => {
            match arg2 {
                true => {
                    let v14 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 157.
                    return v14;
                }
                false => {
                    let v12 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 156.
                    return v12;
                }
                _ => {}
            }
        }
        0x3 => {
            match arg2 {
                true => {
                    let v18 =
                        constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 159.
                    return v18;
                }
                false => {
                    let v16 =
                        constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 158.
                    return v16;
                }
                _ => {}
            }
        }
        0x4 => {
            match arg2 {
                true => {
                    let v22 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 161.
                    return v22;
                }
                false => {
                    let v20 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 160.
                    return v20;
                }
                _ => {}
            }
        }
        0x5 => {
            match arg2 {
                true => {
                    let v26 =
                        constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 163.
                    return v26;
                }
                false => {
                    let v24 =
                        constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 162.
                    return v24;
                }
                _ => {}
            }
        }
        0x6 => {
            let v28 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg3, arg4);
            // Rule at src/opts/icmp.isle line 164.
            return v28;
        }
        0x7 => {
            let v30 = C::imm64(ctx, 0x1);
            let v31 = constructor_iconst(ctx, arg0, v30);
            let v32 = C::subsume(ctx, v31);
            // Rule at src/opts/icmp.isle line 165.
            return v32;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "compose_icmp", "src/opts/icmp.isle line 153"
    )
}
// Generated as internal constructor for term intcc_class.
pub fn constructor_intcc_class<C: Context>(ctx: &mut C, arg0: &IntCC) -> u64 {
    match arg0 {
        &IntCC::Equal => {
            // Rule at src/opts/icmp.isle line 176.
            return 0x3;
        }
        &IntCC::NotEqual => {
            // Rule at src/opts/icmp.isle line 177.
            return 0x3;
        }
        &IntCC::SignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 174.
            return 0x2;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 175.
            return 0x2;
        }
        &IntCC::SignedLessThan => {
            // Rule at src/opts/icmp.isle line 172.
            return 0x2;
        }
        &IntCC::SignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 173.
            return 0x2;
        }
        &IntCC::UnsignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 170.
            return 0x1;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 171.
            return 0x1;
        }
        &IntCC::UnsignedLessThan => {
            // Rule at src/opts/icmp.isle line 168.
            return 0x1;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 169.
            return 0x1;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "intcc_class", "src/opts/icmp.isle line 167"
    )
}
// Generated as internal constructor for term func_addr.
pub fn constructor_func_addr<C: Context>(ctx: &mut C, arg0: Type, arg1: FuncRef) -> Value {
    let v3 = InstructionData::FuncAddr {
        opcode: Opcode::FuncAddr,
        func_ref: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 360.
    return v4;
}
// Generated as internal constructor for term splat.
pub fn constructor_splat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Splat,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 369.
    return v4;
}
// Generated as internal constructor for term swizzle.
pub fn constructor_swizzle<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Swizzle,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 378.
    return v6;
}
// Generated as internal constructor for term x86_pshufb.
pub fn constructor_x86_pshufb<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::X86Pshufb,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 387.
    return v6;
}
// Generated as internal constructor for term insertlane.
pub fn constructor_insertlane<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Uimm8,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::TernaryImm8 {
        opcode: Opcode::Insertlane,
        args: v5.clone(),
        imm: arg3,
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 396.
    return v7;
}
// Generated as internal constructor for term extractlane.
pub fn constructor_extractlane<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Uimm8,
) -> Value {
    let v4 = InstructionData::BinaryImm8 {
        opcode: Opcode::Extractlane,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 405.
    return v5;
}
// Generated as internal constructor for term smin.
pub fn constructor_smin<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Smin,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 414.
    return v6;
}
// Generated as internal constructor for term umin.
pub fn constructor_umin<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Umin,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 423.
    return v6;
}
// Generated as internal constructor for term smax.
pub fn constructor_smax<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Smax,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 432.
    return v6;
}
// Generated as internal constructor for term umax.
pub fn constructor_umax<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Umax,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 441.
    return v6;
}
// Generated as internal constructor for term avg_round.
pub fn constructor_avg_round<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::AvgRound,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 450.
    return v6;
}
// Generated as internal constructor for term uadd_sat.
pub fn constructor_uadd_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::UaddSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 459.
    return v6;
}
// Generated as internal constructor for term sadd_sat.
pub fn constructor_sadd_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::SaddSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 468.
    return v6;
}
// Generated as internal constructor for term usub_sat.
pub fn constructor_usub_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::UsubSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 477.
    return v6;
}
// Generated as internal constructor for term ssub_sat.
pub fn constructor_ssub_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::SsubSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 486.
    return v6;
}
// Generated as internal constructor for term load.
pub fn constructor_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Load,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 495.
    return v6;
}
// Generated as internal constructor for term uload8.
pub fn constructor_uload8<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload8,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 504.
    return v6;
}
// Generated as internal constructor for term sload8.
pub fn constructor_sload8<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload8,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 513.
    return v6;
}
// Generated as internal constructor for term uload16.
pub fn constructor_uload16<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload16,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 522.
    return v6;
}
// Generated as internal constructor for term sload16.
pub fn constructor_sload16<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload16,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 531.
    return v6;
}
// Generated as internal constructor for term uload32.
pub fn constructor_uload32<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload32,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 540.
    return v6;
}
// Generated as internal constructor for term sload32.
pub fn constructor_sload32<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload32,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 549.
    return v6;
}
// Generated as internal constructor for term uload8x8.
pub fn constructor_uload8x8<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload8x8,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 558.
    return v6;
}
// Generated as internal constructor for term sload8x8.
pub fn constructor_sload8x8<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload8x8,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 567.
    return v6;
}
// Generated as internal constructor for term uload16x4.
pub fn constructor_uload16x4<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload16x4,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 576.
    return v6;
}
// Generated as internal constructor for term sload16x4.
pub fn constructor_sload16x4<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload16x4,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 585.
    return v6;
}
// Generated as internal constructor for term uload32x2.
pub fn constructor_uload32x2<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload32x2,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 594.
    return v6;
}
// Generated as internal constructor for term sload32x2.
pub fn constructor_sload32x2<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload32x2,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 603.
    return v6;
}
// Generated as internal constructor for term stack_load.
pub fn constructor_stack_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: StackSlot,
    arg2: Offset32,
) -> Value {
    let v4 = InstructionData::StackLoad {
        opcode: Opcode::StackLoad,
        stack_slot: arg1,
        offset: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 612.
    return v5;
}
// Generated as internal constructor for term stack_addr.
pub fn constructor_stack_addr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: StackSlot,
    arg2: Offset32,
) -> Value {
    let v4 = InstructionData::StackLoad {
        opcode: Opcode::StackAddr,
        stack_slot: arg1,
        offset: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 621.
    return v5;
}
// Generated as internal constructor for term dynamic_stack_load.
pub fn constructor_dynamic_stack_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: DynamicStackSlot,
) -> Value {
    let v3 = InstructionData::DynamicStackLoad {
        opcode: Opcode::DynamicStackLoad,
        dynamic_stack_slot: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 630.
    return v4;
}
// Generated as internal constructor for term dynamic_stack_addr.
pub fn constructor_dynamic_stack_addr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: DynamicStackSlot,
) -> Value {
    let v3 = InstructionData::DynamicStackLoad {
        opcode: Opcode::DynamicStackAddr,
        dynamic_stack_slot: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 639.
    return v4;
}
// Generated as internal constructor for term global_value.
pub fn constructor_global_value<C: Context>(ctx: &mut C, arg0: Type, arg1: GlobalValue) -> Value {
    let v3 = InstructionData::UnaryGlobalValue {
        opcode: Opcode::GlobalValue,
        global_value: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 648.
    return v4;
}
// Generated as internal constructor for term symbol_value.
pub fn constructor_symbol_value<C: Context>(ctx: &mut C, arg0: Type, arg1: GlobalValue) -> Value {
    let v3 = InstructionData::UnaryGlobalValue {
        opcode: Opcode::SymbolValue,
        global_value: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 657.
    return v4;
}
// Generated as internal constructor for term tls_value.
pub fn constructor_tls_value<C: Context>(ctx: &mut C, arg0: Type, arg1: GlobalValue) -> Value {
    let v3 = InstructionData::UnaryGlobalValue {
        opcode: Opcode::TlsValue,
        global_value: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 666.
    return v4;
}
// Generated as internal constructor for term get_pinned_reg.
pub fn constructor_get_pinned_reg<C: Context>(ctx: &mut C, arg0: Type) -> Value {
    let v2 = InstructionData::NullAry {
        opcode: Opcode::GetPinnedReg,
    };
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 675.
    return v3;
}
// Generated as internal constructor for term get_frame_pointer.
pub fn constructor_get_frame_pointer<C: Context>(ctx: &mut C, arg0: Type) -> Value {
    let v2 = InstructionData::NullAry {
        opcode: Opcode::GetFramePointer,
    };
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 684.
    return v3;
}
// Generated as internal constructor for term get_stack_pointer.
pub fn constructor_get_stack_pointer<C: Context>(ctx: &mut C, arg0: Type) -> Value {
    let v2 = InstructionData::NullAry {
        opcode: Opcode::GetStackPointer,
    };
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 693.
    return v3;
}
// Generated as internal constructor for term get_return_address.
pub fn constructor_get_return_address<C: Context>(ctx: &mut C, arg0: Type) -> Value {
    let v2 = InstructionData::NullAry {
        opcode: Opcode::GetReturnAddress,
    };
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 702.
    return v3;
}
// Generated as internal constructor for term table_addr.
pub fn constructor_table_addr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Table,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::TableAddr {
        opcode: Opcode::TableAddr,
        arg: arg2,
        table: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 711.
    return v6;
}
// Generated as internal constructor for term iconst.
pub fn constructor_iconst<C: Context>(ctx: &mut C, arg0: Type, arg1: Imm64) -> Value {
    let v3 = InstructionData::UnaryImm {
        opcode: Opcode::Iconst,
        imm: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 720.
    return v4;
}
// Generated as internal constructor for term f32const.
pub fn constructor_f32const<C: Context>(ctx: &mut C, arg0: Type, arg1: Ieee32) -> Value {
    let v3 = InstructionData::UnaryIeee32 {
        opcode: Opcode::F32const,
        imm: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 729.
    return v4;
}
// Generated as internal constructor for term f64const.
pub fn constructor_f64const<C: Context>(ctx: &mut C, arg0: Type, arg1: Ieee64) -> Value {
    let v3 = InstructionData::UnaryIeee64 {
        opcode: Opcode::F64const,
        imm: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 738.
    return v4;
}
// Generated as internal constructor for term vconst.
pub fn constructor_vconst<C: Context>(ctx: &mut C, arg0: Type, arg1: Constant) -> Value {
    let v3 = InstructionData::UnaryConst {
        opcode: Opcode::Vconst,
        constant_handle: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 747.
    return v4;
}
// Generated as internal constructor for term shuffle.
pub fn constructor_shuffle<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Immediate,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::Shuffle {
        opcode: Opcode::Shuffle,
        args: v5.clone(),
        imm: arg3,
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 756.
    return v7;
}
// Generated as internal constructor for term null.
pub fn constructor_null<C: Context>(ctx: &mut C, arg0: Type) -> Value {
    let v2 = InstructionData::NullAry {
        opcode: Opcode::Null,
    };
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 765.
    return v3;
}
// Generated as internal constructor for term select.
pub fn constructor_select<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::Select,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 774.
    return v7;
}
// Generated as internal constructor for term select_spectre_guard.
pub fn constructor_select_spectre_guard<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::SelectSpectreGuard,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 783.
    return v7;
}
// Generated as internal constructor for term bitselect.
pub fn constructor_bitselect<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::Bitselect,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 792.
    return v7;
}
// Generated as internal constructor for term x86_blendv.
pub fn constructor_x86_blendv<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::X86Blendv,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 801.
    return v7;
}
// Generated as internal constructor for term vany_true.
pub fn constructor_vany_true<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::VanyTrue,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 810.
    return v4;
}
// Generated as internal constructor for term vall_true.
pub fn constructor_vall_true<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::VallTrue,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 819.
    return v4;
}
// Generated as internal constructor for term vhigh_bits.
pub fn constructor_vhigh_bits<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::VhighBits,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 828.
    return v4;
}
// Generated as internal constructor for term icmp.
pub fn constructor_icmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &IntCC,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);
    let v6 = InstructionData::IntCompare {
        opcode: Opcode::Icmp,
        args: v5.clone(),
        cond: arg1.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 837.
    return v7;
}
// Generated as internal constructor for term icmp_imm.
pub fn constructor_icmp_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &IntCC,
    arg2: Value,
    arg3: Imm64,
) -> Value {
    let v5 = InstructionData::IntCompareImm {
        opcode: Opcode::IcmpImm,
        arg: arg2,
        cond: arg1.clone(),
        imm: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 846.
    return v6;
}
// Generated as internal constructor for term iadd.
pub fn constructor_iadd<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Iadd,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 855.
    return v6;
}
// Generated as internal constructor for term isub.
pub fn constructor_isub<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Isub,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 864.
    return v6;
}
// Generated as internal constructor for term ineg.
pub fn constructor_ineg<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Ineg,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 873.
    return v4;
}
// Generated as internal constructor for term iabs.
pub fn constructor_iabs<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Iabs,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 882.
    return v4;
}
// Generated as internal constructor for term imul.
pub fn constructor_imul<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Imul,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 891.
    return v6;
}
// Generated as internal constructor for term umulhi.
pub fn constructor_umulhi<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Umulhi,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 900.
    return v6;
}
// Generated as internal constructor for term smulhi.
pub fn constructor_smulhi<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Smulhi,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 909.
    return v6;
}
// Generated as internal constructor for term sqmul_round_sat.
pub fn constructor_sqmul_round_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::SqmulRoundSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 918.
    return v6;
}
// Generated as internal constructor for term x86_pmulhrsw.
pub fn constructor_x86_pmulhrsw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::X86Pmulhrsw,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 927.
    return v6;
}
// Generated as internal constructor for term udiv.
pub fn constructor_udiv<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Udiv,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 936.
    return v6;
}
// Generated as internal constructor for term sdiv.
pub fn constructor_sdiv<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Sdiv,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 945.
    return v6;
}
// Generated as internal constructor for term urem.
pub fn constructor_urem<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Urem,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 954.
    return v6;
}
// Generated as internal constructor for term srem.
pub fn constructor_srem<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Srem,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 963.
    return v6;
}
// Generated as internal constructor for term iadd_imm.
pub fn constructor_iadd_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::IaddImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 972.
    return v5;
}
// Generated as internal constructor for term imul_imm.
pub fn constructor_imul_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::ImulImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 981.
    return v5;
}
// Generated as internal constructor for term udiv_imm.
pub fn constructor_udiv_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::UdivImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 990.
    return v5;
}
// Generated as internal constructor for term sdiv_imm.
pub fn constructor_sdiv_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::SdivImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 999.
    return v5;
}
// Generated as internal constructor for term urem_imm.
pub fn constructor_urem_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::UremImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1008.
    return v5;
}
// Generated as internal constructor for term srem_imm.
pub fn constructor_srem_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::SremImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1017.
    return v5;
}
// Generated as internal constructor for term irsub_imm.
pub fn constructor_irsub_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::IrsubImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1026.
    return v5;
}
// Generated as internal constructor for term iadd_cin.
pub fn constructor_iadd_cin<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::IaddCin,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1035.
    return v7;
}
// Generated as internal constructor for term uadd_overflow_trap.
pub fn constructor_uadd_overflow_trap<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: &TrapCode,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::IntAddTrap {
        opcode: Opcode::UaddOverflowTrap,
        args: v5.clone(),
        code: arg3.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1044.
    return v7;
}
// Generated as internal constructor for term isub_bin.
pub fn constructor_isub_bin<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::IsubBin,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1053.
    return v7;
}
// Generated as internal constructor for term band.
pub fn constructor_band<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Band,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1062.
    return v6;
}
// Generated as internal constructor for term bor.
pub fn constructor_bor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Bor,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1071.
    return v6;
}
// Generated as internal constructor for term bxor.
pub fn constructor_bxor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Bxor,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1080.
    return v6;
}
// Generated as internal constructor for term bnot.
pub fn constructor_bnot<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Bnot,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1089.
    return v4;
}
// Generated as internal constructor for term band_not.
pub fn constructor_band_not<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::BandNot,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1098.
    return v6;
}
// Generated as internal constructor for term bor_not.
pub fn constructor_bor_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::BorNot,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1107.
    return v6;
}
// Generated as internal constructor for term bxor_not.
pub fn constructor_bxor_not<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::BxorNot,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1116.
    return v6;
}
// Generated as internal constructor for term band_imm.
pub fn constructor_band_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::BandImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1125.
    return v5;
}
// Generated as internal constructor for term bor_imm.
pub fn constructor_bor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Imm64) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::BorImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1134.
    return v5;
}
// Generated as internal constructor for term bxor_imm.
pub fn constructor_bxor_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::BxorImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1143.
    return v5;
}
// Generated as internal constructor for term rotl.
pub fn constructor_rotl<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Rotl,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1152.
    return v6;
}
// Generated as internal constructor for term rotr.
pub fn constructor_rotr<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Rotr,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1161.
    return v6;
}
// Generated as internal constructor for term rotl_imm.
pub fn constructor_rotl_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::RotlImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1170.
    return v5;
}
// Generated as internal constructor for term rotr_imm.
pub fn constructor_rotr_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::RotrImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1179.
    return v5;
}
// Generated as internal constructor for term ishl.
pub fn constructor_ishl<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Ishl,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1188.
    return v6;
}
// Generated as internal constructor for term ushr.
pub fn constructor_ushr<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Ushr,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1197.
    return v6;
}
// Generated as internal constructor for term sshr.
pub fn constructor_sshr<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Sshr,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1206.
    return v6;
}
// Generated as internal constructor for term ishl_imm.
pub fn constructor_ishl_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::IshlImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1215.
    return v5;
}
// Generated as internal constructor for term ushr_imm.
pub fn constructor_ushr_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::UshrImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1224.
    return v5;
}
// Generated as internal constructor for term sshr_imm.
pub fn constructor_sshr_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::SshrImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1233.
    return v5;
}
// Generated as internal constructor for term bitrev.
pub fn constructor_bitrev<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Bitrev,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1242.
    return v4;
}
// Generated as internal constructor for term clz.
pub fn constructor_clz<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Clz,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1251.
    return v4;
}
// Generated as internal constructor for term cls.
pub fn constructor_cls<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Cls,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1260.
    return v4;
}
// Generated as internal constructor for term ctz.
pub fn constructor_ctz<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Ctz,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1269.
    return v4;
}
// Generated as internal constructor for term bswap.
pub fn constructor_bswap<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Bswap,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1278.
    return v4;
}
// Generated as internal constructor for term popcnt.
pub fn constructor_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Popcnt,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1287.
    return v4;
}
// Generated as internal constructor for term fcmp.
pub fn constructor_fcmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &FloatCC,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);
    let v6 = InstructionData::FloatCompare {
        opcode: Opcode::Fcmp,
        args: v5.clone(),
        cond: arg1.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1296.
    return v7;
}
// Generated as internal constructor for term fadd.
pub fn constructor_fadd<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fadd,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1305.
    return v6;
}
// Generated as internal constructor for term fsub.
pub fn constructor_fsub<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fsub,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1314.
    return v6;
}
// Generated as internal constructor for term fmul.
pub fn constructor_fmul<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fmul,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1323.
    return v6;
}
// Generated as internal constructor for term fdiv.
pub fn constructor_fdiv<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fdiv,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1332.
    return v6;
}
// Generated as internal constructor for term sqrt.
pub fn constructor_sqrt<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Sqrt,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1341.
    return v4;
}
// Generated as internal constructor for term fma.
pub fn constructor_fma<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::Fma,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1350.
    return v7;
}
// Generated as internal constructor for term fneg.
pub fn constructor_fneg<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fneg,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1359.
    return v4;
}
// Generated as internal constructor for term fabs.
pub fn constructor_fabs<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fabs,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1368.
    return v4;
}
// Generated as internal constructor for term fcopysign.
pub fn constructor_fcopysign<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fcopysign,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1377.
    return v6;
}
// Generated as internal constructor for term fmin.
pub fn constructor_fmin<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fmin,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1386.
    return v6;
}
// Generated as internal constructor for term fmin_pseudo.
pub fn constructor_fmin_pseudo<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::FminPseudo,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1395.
    return v6;
}
// Generated as internal constructor for term fmax.
pub fn constructor_fmax<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fmax,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1404.
    return v6;
}
// Generated as internal constructor for term fmax_pseudo.
pub fn constructor_fmax_pseudo<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::FmaxPseudo,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1413.
    return v6;
}
// Generated as internal constructor for term ceil.
pub fn constructor_ceil<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Ceil,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1422.
    return v4;
}
// Generated as internal constructor for term floor.
pub fn constructor_floor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Floor,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1431.
    return v4;
}
// Generated as internal constructor for term trunc.
pub fn constructor_trunc<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Trunc,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1440.
    return v4;
}
// Generated as internal constructor for term nearest.
pub fn constructor_nearest<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Nearest,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1449.
    return v4;
}
// Generated as internal constructor for term is_null.
pub fn constructor_is_null<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::IsNull,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1458.
    return v4;
}
// Generated as internal constructor for term is_invalid.
pub fn constructor_is_invalid<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::IsInvalid,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1467.
    return v4;
}
// Generated as internal constructor for term bitcast.
pub fn constructor_bitcast<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
) -> Value {
    let v4 = InstructionData::LoadNoOffset {
        opcode: Opcode::Bitcast,
        arg: arg2,
        flags: arg1,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1476.
    return v5;
}
// Generated as internal constructor for term scalar_to_vector.
pub fn constructor_scalar_to_vector<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::ScalarToVector,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1485.
    return v4;
}
// Generated as internal constructor for term bmask.
pub fn constructor_bmask<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Bmask,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1494.
    return v4;
}
// Generated as internal constructor for term ireduce.
pub fn constructor_ireduce<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Ireduce,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1503.
    return v4;
}
// Generated as internal constructor for term snarrow.
pub fn constructor_snarrow<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Snarrow,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1512.
    return v6;
}
// Generated as internal constructor for term unarrow.
pub fn constructor_unarrow<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Unarrow,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1521.
    return v6;
}
// Generated as internal constructor for term uunarrow.
pub fn constructor_uunarrow<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Uunarrow,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1530.
    return v6;
}
// Generated as internal constructor for term swiden_low.
pub fn constructor_swiden_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::SwidenLow,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1539.
    return v4;
}
// Generated as internal constructor for term swiden_high.
pub fn constructor_swiden_high<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::SwidenHigh,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1548.
    return v4;
}
// Generated as internal constructor for term uwiden_low.
pub fn constructor_uwiden_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::UwidenLow,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1557.
    return v4;
}
// Generated as internal constructor for term uwiden_high.
pub fn constructor_uwiden_high<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::UwidenHigh,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1566.
    return v4;
}
// Generated as internal constructor for term iadd_pairwise.
pub fn constructor_iadd_pairwise<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::IaddPairwise,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1575.
    return v6;
}
// Generated as internal constructor for term x86_pmaddubsw.
pub fn constructor_x86_pmaddubsw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::X86Pmaddubsw,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1584.
    return v6;
}
// Generated as internal constructor for term uextend.
pub fn constructor_uextend<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Uextend,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1593.
    return v4;
}
// Generated as internal constructor for term sextend.
pub fn constructor_sextend<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Sextend,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1602.
    return v4;
}
// Generated as internal constructor for term fpromote.
pub fn constructor_fpromote<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fpromote,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1611.
    return v4;
}
// Generated as internal constructor for term fdemote.
pub fn constructor_fdemote<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fdemote,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1620.
    return v4;
}
// Generated as internal constructor for term fvdemote.
pub fn constructor_fvdemote<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fvdemote,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1629.
    return v4;
}
// Generated as internal constructor for term fvpromote_low.
pub fn constructor_fvpromote_low<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FvpromoteLow,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1638.
    return v4;
}
// Generated as internal constructor for term fcvt_to_uint.
pub fn constructor_fcvt_to_uint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtToUint,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1647.
    return v4;
}
// Generated as internal constructor for term fcvt_to_sint.
pub fn constructor_fcvt_to_sint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtToSint,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1656.
    return v4;
}
// Generated as internal constructor for term fcvt_to_uint_sat.
pub fn constructor_fcvt_to_uint_sat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtToUintSat,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1665.
    return v4;
}
// Generated as internal constructor for term fcvt_to_sint_sat.
pub fn constructor_fcvt_to_sint_sat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtToSintSat,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1674.
    return v4;
}
// Generated as internal constructor for term x86_cvtt2dq.
pub fn constructor_x86_cvtt2dq<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::X86Cvtt2dq,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1683.
    return v4;
}
// Generated as internal constructor for term fcvt_from_uint.
pub fn constructor_fcvt_from_uint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtFromUint,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1692.
    return v4;
}
// Generated as internal constructor for term fcvt_from_sint.
pub fn constructor_fcvt_from_sint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtFromSint,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1701.
    return v4;
}
// Generated as internal constructor for term fcvt_low_from_sint.
pub fn constructor_fcvt_low_from_sint<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtLowFromSint,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1710.
    return v4;
}
// Generated as internal constructor for term iconcat.
pub fn constructor_iconcat<C: Context>(ctx: &mut C, arg0: Type, arg1: Value, arg2: Value) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Iconcat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1719.
    return v6;
}
// Generated as internal constructor for term atomic_rmw.
pub fn constructor_atomic_rmw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: &AtomicRmwOp,
    arg3: Value,
    arg4: Value,
) -> Value {
    let v6 = &C::value_array_2_ctor(ctx, arg3, arg4);
    let v7 = InstructionData::AtomicRmw {
        opcode: Opcode::AtomicRmw,
        args: v6.clone(),
        flags: arg1,
        op: arg2.clone(),
    };
    let v8 = C::make_inst_ctor(ctx, arg0, &v7);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1728.
    return v8;
}
// Generated as internal constructor for term atomic_cas.
pub fn constructor_atomic_cas<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Value,
    arg4: Value,
) -> Value {
    let v6 = &C::value_array_3_ctor(ctx, arg2, arg3, arg4);
    let v7 = InstructionData::AtomicCas {
        opcode: Opcode::AtomicCas,
        args: v6.clone(),
        flags: arg1,
    };
    let v8 = C::make_inst_ctor(ctx, arg0, &v7);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1737.
    return v8;
}
// Generated as internal constructor for term atomic_load.
pub fn constructor_atomic_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
) -> Value {
    let v4 = InstructionData::LoadNoOffset {
        opcode: Opcode::AtomicLoad,
        arg: arg2,
        flags: arg1,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1746.
    return v5;
}
// Generated as internal constructor for term extract_vector.
pub fn constructor_extract_vector<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Uimm8,
) -> Value {
    let v4 = InstructionData::BinaryImm8 {
        opcode: Opcode::ExtractVector,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_opt.isle line 1755.
    return v5;
}